第31节：Java基础-类与对象

时间：2018-08-16 23:48:56 阅读：405 评论：0 收藏：0 [点我收藏+]

技术分享图片

前言

Java基础-类与对象，方法的重载，构造方法的重载，static关键字，main()方法，this关键字，包，访问权限，类的继承，继承性，方法的重写，super变量。

方法的重载：成员方法的重载和构造方法的重载

方法的重载

在一个类中可以有多个方法具有相同的名字，但是这些方法的参数个数不同，或参数类型不同，即为方法的重载。

class Demo{
 // one
 void dashu(String name){
  System.out.println(name);
 }
 // two
 void dashu(String name,String score){
  System.out.println(name+score);
 }
 // three
 void dashu(String name,String score,Int age){
  System.out.println(name+score+age);
 }
  public static void main(String[] args){
   Demo demo = new Demo();
   demo.dashu("dashucoding");
   demo.dashu("dashucoding","一百");
   demo.dashu("dashucoding","一百",10);
  }
}

构造方法的重载

class Person{
 String name;
 int age;
 float height;
 float weight;
 // 构造方法
 public Person(){
  age = 13;
  name="dashu"
 }
 public Person(String name){
  this.name = name;
 }
 // 构造方法的重载
 public Person(String name, int age){
  this.name = name;
  this.age = age;
 }
 void print(){
  System.out.println(name+age);
 }
}
class Test{
 public static void main(String[] args){
  Demo demo1,demo2,demo3;
  demo1 = new Demo();
  demo2 = new Demo("dashu");
  demo3 = new Demo("dashu",12);
  demo1.print();
  demo2.print();
  demo3.print();
 }
}

static关键字

被static修饰的变量为静态变量
被static修饰的方法为静态方法

静态变量属于类而不属于类的某个实例，可被直接类名调用，所以叫类变量
静态方法属于类而不属于类的某个实例，可被直接类名调用，所以叫类方法

非静态的成员变量和方法，必须通过实例化后通过对象名来调用
所以叫实例变量和实例方法

实例变量和实例方法通过实例调用，类变量和类方法同样也可以通过实例调用
这点要注意

main()方法

main()方法为静态的，在java虚拟机中执行main()方法时不需要创建main()方法所在类的实例就可调用，因为有static修饰。

例子

class Demo{
 // 定义静态的成员变量
 static int x;
 int y;
 // 定义静态的成员方法，用来获取值
 public static int getX(){
  return x;
 }
 // 定义静态的成员方法，用来设置值
 public static void setX(int newX){
   x = newX;
  }
 public int getY(){
  return y;
 }
 public void setY(int newY){
  y = newY;
 }
}

静态方法可以调用同类的静态成员，不能调用非静态成员，反之能；静态成员可通过类名调用，也可通过实例对象，静态方法中不能使用this和super。

this关键字

this代表使用该方法的当前的对象，只用于实例方法或者构造方法中。

void setAge(int age){
 this.age = age;
} 
Person(String name, int age){
 this.name = name;
 this.age = age; 
}

包

在java中提供了不同的类和接口存放在不同的包中。
常见的包

java.applet
java.awt
java.net
java.util
java.lang
java.io

包的格式：

package 包名[.子包名[…]];

引入java包

import  包层次结构的类名;

访问权限

修饰符：

public、private、protected、友好

private变量和方法

访问权限最小，只能在同一个类中被访问，私有成员可以被对象实例调用，方法被对象实例调用，静态成员可以被类名直接调用。

class Demo{
 private static String name;
 private int age;
 private void print(){
  System.out.println(name+age);
 }
 public static void main(String[] args){
 Demo.name = "dashu";
 Demo d = new Demo();
 d.age = 12;
 d.print();
 }
}

private，类中的私有变量不能被另一个类所引用，私有变量和方法只能在本类中使用。

class Demo{
 private static String name;
 private int age;
 private void print(){
  System.out.println(name+age);
 }
 public static void main(String[] args){
 Demo.name = "dashu";
 Demo d = new Demo();
 d.age = 12;
 d.print();
 }
}
// 另一类
class Da{
 public static void main(String[] args){
  // 非法使用
 Demo.name = "dashu";
 // 非法调用
 Demo d = new Demo();
 d.print();
 }
}

public 访问修饰符，它的访问权限在不同类，不同包的类中访问

默认，友好权限只能被同类或同包中的不同类引用

protected不能在不同包中的类所引用

访问权限	public	protected	友好	private
同类	可以	可以	可以	可以
同包不同类	可以	可以	可以
不同包子类	可以	可以
通用	可以

类的继承

在java中可以单继承，不支持多继承，一个子类只能有一个父类，不能有多个，但一个父类可以有多个派生的子类。

public class Person{
     String name;
     int age;
     public void setAge(int age) {
    this.age=age;
     }
     public void out()   {
        System.out.println("姓名:"+name+" 年龄:"+age+"岁");      
     }
}

// 子类继承父类
public class Student extends Person{
 ...
}