复习(java)：语法：面向对象

1. 类和对象

• 封装，继承，多态

public class Person{
    //定义两个成员变量
    public Sting name;
    public int age;

    public void say(String content){
        System.out.println(comtent);
    }
}

Person p=new Person();
p.name="李刚"；
p.say=29;

2.对象、指针和引用

• p是引用变量，放入栈内存，指向堆内存，堆内存存放实际的对象

this指针

• this指针指向调用该方法的对象：
  （1）构造器中引用该构造器初始化对象；
  （2）在方法中引用该对象的方法：用类中的一个方法可以访问类中的另一个方法和变量
• static不可以使用this

3. 方法的参数传递机制

• 交换$swap(a, b)$的值

import java.util.*;
public class Solution{  
    public static void swap(int a, int b){
        int tmp=a;
        a=b;
        b=tmp;
        System.out.println("swap 方法里的，a= "+a+'\n'+"swap 方法里的，b= "+b);
    }
    public static void main(String[] args){     
        int a=6;
        int b=9;
        System.out.println("初始化，a= "+a+'\n'+"初始化，b= "+b);
        swap(6,9);      
        System.out.println("交换后，a= "+a+'\n'+"交换后，b= "+b);
    }
}

//-----
/*
初始化，a= 6
初始化，b= 9
swap 方法里的，a= 9
swap 方法里的，b= 6
交换后，a= 6
交换后，b= 9
*/

• 程序开辟：main栈区和swap栈区

• 引用类型的交换

/*import java.util.*;

class Solution{
public  static void main(String[] args)
}*/

import java.util.*;

class DataWrap{
    int a;
    int b;
}


public class Solution{

    public static void swap(DataWrap dw){
        int tmp=dw.a;
        dw.a=dw.b;
        dw.b=tmp;
        System.out.println("swap 方法里的，a= "+dw.a+'\n'+"swap 方法里的，b= "+dw.b);
    }
    public static void main(String[] args){

        DataWrap dw = new DataWrap();
        dw.a=6;
        dw.b=9;
        System.out.println("初始化，a= "+dw.a+'\n'+"初始化，b= "+dw.b);
        swap(dw);

        System.out.println("交换后，a= "+dw.a+'\n'+"交换后，b= "+dw.b);

    }
}
/*
初始化，a= 6
初始化，b= 9
swap 方法里的，a= 9
swap 方法里的，b= 6
交换后，a= 9
交换后，b= 6
*/

• 传参是对象 $DataWrap$
• 传递的是引用的地址值
• 所以堆内存的值保存了

---

4. 形参的个数

import java.util.*;

public class Solution{

    public static void test(int a, String ... books){
        //books看作是数组
        for(String tmp:books)
            System.out.println(tmp);
    }
    public static void main(String[] args){

        test(5,"a","b");
    }
}

//数组的形式

public class Solution{

    public static void test(int a, String[] books){
        //books看作是数组
        for(String tmp:books)
            System.out.println(tmp);
    }
    public static void main(String[] args){

        test(5,new String[]{"a","b"});
    }
}

---

5. 方法的重载

• 一个类定义多个同名方法
• 参数不同，通过参数来区分

//可变参数的重载
public void test(String msg)

public void test(String ... books)

//传参

ob.test() ; //调用 test(String ... books)
ob.test("a","b") ; //调用 test(String ... books)
ob.test("a") ; //调用 test(String msg)
ob.test(new String[]{"a"}) ; //调用 test(String msg)

---

6. 成员变量和局部变量

• 成员变量：实例变量+类变量(static 修饰)
• 局部变量

成员变量的初始化和内存中的运行机制

public string name;
public static int eyeNum;

//创建第一个Person对象
Person p1 = new Person();
//创建第二个Person对象
Person p2 = new Person();

//分别为两个对象的name实例赋值
p1.name="张三";
p2.name="李四";

//eyeNum
p1.eyeNum=2;
p2.eyeNum=3;

• Person p1 = new Person();
  第一次使用Person类，加载Person类，初始化Person类：分配内存空间，指定默认初始值；
  为Person创建第一个类对象
  (static)变量eyeNums初始化为0

---

7. 封装

@@@	private	default	protected	public
同一个类	yes	yes	yes	yes
同一个包		yes	yes	yes
同一个包或者不同包的子类中			yes	yes
全部范围				yes

* 原则
1. 类的成员变量一般用private，只有static的会考虑使用public；辅助类内部其他方法的方法，使用private
2. 某类注意做其他类的父类，希望被子类重写，而不是调用，用protected
3. 希望暴露给其他类调用的用public

8. 包

---

9. 构造器

• 初始化类，系统将类的变量设置为0或者false，引用类型的实例设置为null

构造器的重载

public class Test{
    public String name;
    public int count;

    public Test() {}
    public Test(String name,int count) {
        this.name=name;
        this.count=count;
    }
    public Test(String name,int count，double weight) {
        this(name, color);
        this.weight = weight;
    }
}

---

10. 类的继承

• 简单的继承
  
  1. 每个类最多继承一个父类
  2. 所有java类继承于

public class Friut{
    public double weight;
    public void info(){
        println{...}
    }
}

pub;ic class apple extends Friut{
    public static void main(String[] args){
        Apple a= new Apple();
        a.weight=56;
        a.info();
    }
}

• 重写父类的方法

public class bird{
    pblic void fly()
    {
        println(){"我是fly"}
    }
}

public class Ostrich extends Bird{
    public fly()
    {pintln(){我是Ostrich}}

    public static void main(String[] args ){
        Ostrich OS=NEW Ostrich();
        OS.fly();  //执行Ostrich对象的fly方法
    }
}

• 子类覆盖了父类的方法后，子类对象无法访问父类

super

• 需要在子类中调用父类被覆盖的方法，super

class BaseClass{
    public int a=5;
}

public class SubClass extends BaseClass{
    public int a=7;
    public void accessOwner(){
        System.out.println(a);
    }
    public void accessBase(){
        System.out.println(super.a); //访问父类的实例
    }

    public static void main(String[] args){
        SubClass sc=new SubClass();
        sc.accessOwner(); // 输出7
        sc.accessBase(); //输出5
    }
}

• BaseClass和Subclass都定义了变量a
• SubClass的a实例变化会隐藏BaseClass的a的实例变量
• 创建SubClass对象，为SubClass对象分配两块内存，一块存储Subclass的a，一个存储BaseClass的a

• 查找方法：

  1. 查找该方法中是否含有名字为a的局部变量
  2. 查找当前类中是否包含名字为a的成员变量
  3. 查找a的直接父类是否包含a的成员变量，依次上溯，直到Object类

• 向上转换程序

class p{
    public String tag = "我是父类"；
}

class Derived extends p{
    private String tag = "我是子类";
}

public class HideTest{
    public static void main(String[] args){
        Derived d = new Derived();
        //不可以访问Derived的私有变量

        System.out.println(d.tag); //error

        //向上转换
        System.out.println(((p)d).tag);
    }
}

---

11. 调用父类的构造器

• 构造器中调用另一个重载的构造器，使用this
• 子类构造器中调用父类构造器，使用super来完成

class base{
    public double size;
    public String name;
    public Base (double size,String name){
        this.size=size;
        this.name=name;
    }
}

public class sub extends base{
    public String color;
    public Sub(double size,String name, String color){
        //super调用父类的构造器
        super(size,name);
        this.color=color;
    }

}

构造器的继承顺序

java.land.Object<-----类A（继承）<------类 B(继承)

• 调用的顺序：先执行Object，然后执行类A，然后执行类B

---

11. 多态

• java引用变量的两个类型：编译时类型；运行时类型；
• 编译时类型：声明变量时使用的类型决定
• 运行时类型：实际赋给该变量的对象决定
• 不一致，则产生多态

class b{
    public int book = 6;
    public void base(){
        System.out.println("父类的方法");
    }
    public void test(){
        System.out.println("父类的被覆盖的方法");
    }

}

public class sub extends b{
    public String book = "轻量级的java";
    public void test(){
        System.out.println("子类覆盖父类的方法");

    }

    public void sub(){
        System.out.println("子类的普通方法");
    }

    public static void main(String[] args){
        b bc = new b(); //编译类型和运行类型一样，无多态
        sub sc=new sub(); //编译类型和运行类型一样，无多态
        b ploybc=new sub(); //多态
        ploybc.base();  //父类调用子类的方法


    }
}

---

12. 引用类型的强制类型转换

• 基本类型的强制转换，只可以在数值类型之间，数值类型包括整数型，字符型和浮点型
• 引用类型的转换在继承的两个类之间
• (type)变量

13. instanceof 运算符

• 判断前面的对象是否是后面的类，或者子类，实例；

=>
instanceof和(type)的联合使用

---

15. 继承和组合

• 类复用的方法：继承和组和

继承使用的原则

• 尽量隐藏父类的内部数据。设为private
• 不要让子类随意访问，修改父类
• 父类构造器中不要调用子类重写的方法

利用组合实现复用

• 继承的方式

class Animal{
    private void beat(){
        System.out.println("心脏跳动...");
    }
    public void breath(){
        beat();
        System.out.println("吸气，吐气，呼吸...")
    }

}

//继承Animal, 直接使用父类的breath方法

class Bird extends Animal{
    public void fly(){
        System.out.println("我在天空自由的飞翔");
    }



}

//继承Animal,直接使用父类的breath方法

class wolf extends Animal{
    public  void run(){
        System.out.println("我在陆地上奔跑")；
    }
}

public class InheriTest{
    public static void main(String[] args){
        Bird b = new Bird();
        b.breath();
        b.fly();
        wolf w = new wolf();
        w.breath();
        w.run();
    }
}

• 组合的方法

class Animal{
    private void beat(){
        System.out.println("心脏跳动...");
    }
    public void breath(){
        beat();
        System.out.println("吸气，吐气，呼吸...")
    }

}


class Bird{
    private Animal a;
    public  Bird(Animal a){
        this.a=a;
    }
    public void breath(){
        a.breath();
    }
    public void fly(){
        System.out.println("我在天空自在的飞翔...");
    }
}

class wolf{
    private Animal a;
    public wolf(Animal  a){
        this.a = a;
    }

    public void breath(){
        a.breath();
    }   
    public void run(){
        System.out.println("我在陆地上奔跑")；
    }
}

public class CompositeTest{
    public static void  main(String[] args){
        Animal al = new Animal();
        Bird b = new Bird(al);
        b.breath();
        b.fly();

        Animal a2 = new Animal();
        wolf w=new wolf(a2);
        w.breath();
        w.run();

    }
}

---

16. 初始化块

• 初始化块在构造器之前