Java面向对象三

• 在Java中万事万物皆对象
• 一般是先写类，然后根据类创建对象的对象

构造器和方法的区别

1. 构造器没有方法的返回值类型
2. 构造器的方法体内部不能有return语句
3. 构造器的名字很特殊，必须和类名一样

构造器

构造器的作用

• 不是为了创建对象，因为在调用这个构造器之前就已经创建好了这个构造器的对象，且属性有默认的初始化的值

构造器的目的

• 是给属性进行赋值操作

一般不对空构造器进行初始化操作，否则每个对象的属性就一样了

创建对象的过程

1. 第一次遇到类，先加载类（只会加载一次）
2. 创建对象，在堆中开辟空间
3. 对对象进行初始化，默认初始值
4. new关键字调用构造器并执行构造方法，在构造器中对属性重新赋值

this关键字

• this修饰方法

  • 在同一个类中方法可以相互调用，this.可以省略不写

  public class Person {//属性int age;String name;double height;//空构造器public Person() {}//有参数构造器public Person(int age, String name, double height) {this.age = age;this.name = name;this.height = height;}public void gem(){pla();this.pla();//System.out.println("上网");System.out.println("洗剪吹");}public void pla(){System.out.println("上网");System.out.println(age);System.out.println(this.age);}
  

• this修饰属性

  • 属性名和形参发生重名时或者属性名和局部变量重名时，会发生就近原则；所以要直接使用变量名时就会指向离最近的那个形参或者局部变量，这如果要表示属性需要在前面加上this.修饰，如果访问属性不发生重名问题this.也可以省略不写

  public class Person {//属性int age;String name;double height;//空构造器public Person() {}//有参数构造器public Person(int age, String name, double height) {this.age = age;this.name = name;this.height = height;}public void eat(){int age = 17;System.out.println(age);//就近原则，局部变量的ageSystem.out.println(this.age);//属性赋值的ageSystem.out.println("蹭饭");}
  }
  

• this修饰构造器

  • 在同一个类中的构造器可以相互用this调用
  • this修饰构造器必须写在第一行

  public class Person {//属性int age;String name;double height;//空构造器public Person() {}//有参数构造器public Person(int age, String name, double height) {this(age, name);//此处调用下面有两个参数的构造器，此代码必须写在第一行this.age = age;this.name = name;this.height = height;}public Person(int age, String name) {this(age);//此处调用下面的只要一个参数的构造器里面的age，此代码必须写在第一行this.age = age;this.name = name;}public Person(int age) {this.age = age;}
  

static关键字

• static修饰属性

  • 在类加载的时候，会将静态内容加载到方法区的静态域里面
  • 静态的内容会被所有这个类的对象共享
  • 可以通过类名.属性名的方式访问
  • 总结
    1. 在类加载的时候一起加载进方法区的静态域里面
    2. 比对象存在时间要早
    3. 访问方式
       • 对象名.属性名
       • 类名.属性名（推荐）
  • 应用场景
    • 特定数据要在内存中共享（只有一块）
  • 属性
    • 静态属性（类变量）
    • 非静态属性（实例变量）

  public class Test {//属性int id;static int sid;public static void main(String[] args) {Test.sid = 113;System.out.println(Test.sid);//创建具体对象Test test1 = new Test();test1.id = 11;test1.sid = 11;Test test2 = new Test();test2.id = 21;test2.sid = 21;Test test3 = new Test();test3.id = 31;test3.sid = 31;//读取属性值System.out.println(test1.id);System.out.println(test2.id);System.out.println(test3.id);System.out.println(test1.sid);System.out.println(test2.sid);System.out.println(test3.sid);}
  }
  

• static修饰方法

  • static和public都是修饰符，并列时没有先后顺序
  • 在静态方法中不能访问非静态属性
  • 在静态方法中不能访问非静态方法
  • 在静态方法中不能使用this关键字
  • 非静态方法可以用对象名.方法名调用
  • 静态方法可以用对象名.方法名调用也可以用类名.方法名调用（推荐）
  • 在同一个类中可以直接调用

  public class Demo {int id;static int sid;public void de(){System.out.println(id);System.out.println(sid);System.out.println("--de---");}//static和public都是修饰符，并列时没有先后顺序public static void ae(){//System.out.println(id); 在静态方法中不能访问非静态属性//在静态方法中不能访问非静态方法/*this.de();de();*///System.out.println(this.id); 在静态方法中不能使用this关键字System.out.println(sid);System.out.println("--ae---");}public static void main(String[] args) {//非静态方法可以用对象名.方法名调用Demo demo = new Demo();demo.de();//静态方法可以用对象名.方法名调用也可以用类名.方法名调用（推荐）Demo.ae();demo.ae();//在同一个类中可以直接调用ae();}
  }
  

代码块

• 类的组成

  • 属性、方法、代码块、构造器，内部类

• 代码块分类

  • 普通块

    • 限制了局部变量的作用范围

    {System.out.println("这是普通块");int num = 11;System.out.println(num);}
    

  • 静态块

    • 在静态块中只能访问静态属性和静态方法
    • 一般用于执行一些全局性的初始化操作

    static {System.out.println("这是静态块");}
    

  • 构造块

     {System.out.println("这是构造块");}
    

  • 代码块执行顺序

    1. 最先执行静态块，只在类加载的时候执行一次，所以一般创建工厂，数据库的初始化信息都写入静态块

    2. 然后执行构造块（不经常用）

    3. 再执行构造器

    4. 最后执行方法中的普通块

Java中类都是继承Object，启动的时候就已经加载

super

• 当子类和父类的方法或者属性重名的时候，必须加上super
• 通常情况下super可以省略不写
• super和this两个不能共同存在

Object类

equals方法的作用

• 对对象内容是否相等的一个比较方式
• 父类Object提供的equals就是在比较==地址，没有实际意义
• 一般不直接使用父类Object提供的equals，而是在子类中对这个方法进行重写

//对equals方法进行重写public boolean equals(Object obj){//将obj转为Miph类型Miph other = (Miph) obj;if (this.getBrand() == other.getBrand() && this.getPice() == other.getPice() && this.getYear() == other.getYear()){return true;}return false;}

• instanceof关键字
  • 判断a对象是否是b这个类的实例，是就返回true，不是就返回false

 public boolean equals(Object obj){if (obj instanceof Miph) {//将obj转为Miph类型Miph other = (Miph) obj;if (this.getBrand() == other.getBrand() && this.getPice() == other.getPice() && this.getYear() == other.getYear()) {return true;}}return false;}

向上、向下转型

• 父类往子类转型就是向下转型
• 子类往父类转型就是向上转型

public class Demo {Pig p = new Pig();Animal an = p;//向上转型an.shout();//将Animal转为pigPig pig = (Pig)an;//向下转型pig.eat();pig.age = 13;pig.weiht = 66;}

抽象类

• 一个类中如果有方法是抽象方法，那么这个类也会变成一个抽象类
• 一个方法的方法体被去掉然后被abstract修饰，这个方法就变成了抽象方法
• 抽象类可以被其他类继承
• 一个类继承一个抽象类，这个类可以变成抽象类也可以重写抽象类，一般都是对抽象类重写
• 继承抽象类必须重写全部抽象方法或者加abstract修饰
• 抽象类不可以创建对象，但是可以创建子类对象

接口

接口的作用

• 定义规则，与抽象类不同的是，这个是接口，抽象类是类

内部类

成员内部类

• 成员内部类有属性，方法，构造器等

• 修饰符：private，default，protect，public，final，abstract

• 内部类可以访问外部类的内容

• 静态内部类只能访问外部类中被static修饰的内容

• 外部类需要先创建内部类对象才能访问内部类的内容

• 内部类和外部类属性重名时id调用方法

 System.out.println(age);System.out.println(this.age);System.out.println(Teston.this.age);

创建内部类对象

• 静态成员内部类

Teston.W w = new Teston.W();

• 非静态成员内部类

Teston t = new Teston();
Teston.F f = t.new F();

局部内部类

• 局部内部类访问到的变量必须是被final修饰的
• 匿名内部类

public Comparable maethc() {class B implements Comparable{@Overridepublic int compareTo(Object o){return 100;}}return new B();}public Comparable maethc2() {//匿名内部类return new Comparable(){@Overridepublic int compareTo(Object o){return 200;}};
}