跟着刚哥梳理java知识点——面向对象（八）

面向对象的核心概念：类和对象。

　　类：对一类事物描述，是抽象的、概念上的定义。

　　对象：实际存在的该类事物的每个个体，因而也成为实例（Instance）。

Java类及类的成员：属性（成员变量Field）和方法（method）。

类对象的内存结构：

Animal a1 = new Animal();
a1.name = "花花";
a1.age = 3;

之前梳理数组的时候说过，栈中的对象存放对象的引用及Animal a1的a1这个引用。堆空间都是new出的东西包括成员变量。

　　① 在栈中声明一个a1的引用变量

　　② 在堆中申请一块区域存储new Animal并为成员变量赋默认值（name=null，age=0）。

　　③ a1的引用变量指向堆的new Animal的首地址（16进制数字）。

　　④ a1.name="花花"：修改成员变量name值为花花。

　　⑤ a1.age = 3：修改成员变量age值为3。

Animal a2 = new Animal();

每次new出来的对象都是在堆中重新申请的一个新空间

Animal a3 = a1;
a3.name = "草草"

① 在栈中声明一个a3的引用变量

② a3的引用变量指向a1的指向的堆空间的首地址

③ a3.name = "草草":修改成员变量name值为"草草"。

最终，a1和a3的成员变量name都修改成了草草。

类的== 和equals

　== 表示对象引用的地址是否相等，即16位的首地址码是否一致。

类没有重写equals，所以用的是Object的equals的方法，看源码就能看出来，和==一样。

想让比较的两个类所有属性值都一样的情况下就相等的话，需要自己重写equals方法。

类的成员之一：属性

成员变量（属性）和局部变量

1、修饰符

　　① 成员变量：public、private、protected、default、final、static

　　② 局部变量：final

　　笔试题：

　　public class aClass {
　　　　void run() {
　　　　　　static int i = 0;
　　　　　　i++;
　　　　　　System.out.println(i);
　　　　}
　　　　public static void main(String args[]) {
　　　　　　aClass obj = new aClass();
　　　　　　obj.run();
　　　　　　obj.run();
　　　　}
　　} 

结果为：A：0    B：1    C：2    D：编译错误

很明显是选D，因为局部变量只能用修饰符final修饰。

2、默认初始化值：

　　① 局部变量：类的局部变量和数组元素的默认初始化值一致的。

　　② 成员变量：没有默认值。

3、内存中存放的位置：

　　① 局部变量：堆

　　② 成员变量：栈

　　① 在栈中声明一个p1的引用变量

　　② 在堆中申请一块区域存储new Person并为成员变量赋默认值（name=null，age=0，sex=false）。

　　③ p1的引用变量指向堆的new Person的首地址（16进制数字）。

　　④ 在栈中申请n的变量并赋值为付昊（n为形参的参数名字）

　　⑤ 将n这个局部变量的值赋值给刚才new Person的成员变量name

　　⑥ setName执行完毕后，n这个局部变量销毁。

4、类对象的属性赋值顺序：

　　① 属性的默认值：private int age;

　　② 属性的显式赋值：private int age = 1;

　　③ 构造器给属性赋值：public Person(int a){age = a;}

　　④ 通过setter方法赋值：public void setAge(int n){age = n;}

 类的成员之二：方法

1、修饰符：private、protect、public、static、final、synchronize。

2、重载：方法名字相同，参数列表不同（参数个数不同和类型不同）。

3、重写：继承中子类重新实现了父类的方法。

　　① 要求子类方法名字和参数列表完全和父类一样。

　　② 子类方法的修饰符不能小于父类方法的修饰符。

4、形参：

java中的参数传递机制：值传递

　　① 基本数据类型传递（传递的值是具体的实参的基本数据类型的值）

public class TestArgsTransfer {
    public void swap(int i,int j){
        int temp = i;
        i = j;
        j = temp;
    }
    public static void main(String[] args){
        TestArgsTransfer tt = new TestArgsTransfer();
        int i = 10;
        int j = 5;
        tt.swap(i,j);
    }
}

内存结构

　　② 引用数据类型传递（传递的值是引用对象的16位的首地址值）

public class TestArgsTransfer {
    public void swap(DataSwap d){
        int temp = d.i;
        d.i = d.j;
        d.j = temp;
    }
    public static void main(String[] args){
        TestArgsTransfer tt = new TestArgsTransfer();
        DataSwap ds = new DataSwap();
        tt.swap(ds);
    }
}
class DataSwap{
    int i = 10;
    int j = 5;
}

类的成员之三：构造器：

特点：

　　① 和类名字一致

　　② 没有返回值

　　③ 只能被4个访问权限修饰符修饰

作用：

　　① 创建对象

　　② 给创建的对象的属性赋值，通过构造器的形参实现。

【知识点】：

　　① 若不显式的声明类的构造器的话，程序会默认的提供一个空参的构造器。

　　② 若显式的声明的类的构造器的话，那么默认的构造器就不再提供。

　　③ 类的多个构造器之间形成重载。

java封装性：

1、将属性私有化，然后通过调用getter和setter方法来获取或者设置属性。

　　为什么不直接使用对象.属性直接使用属性呢？

　　设想，你有一个Person类代表一个人，Person有一个char类型的sex字段表示性别，理论上，sex只接受两个值， 'M '和 'F '，但如果你把sex字段设为public，

　　你很难限制你的用户只给它赋 'M '或 'F '值。将sex设为private，再用setSex()来设置性别，你就完全可以控制这种行为了。而且你还可以控制只能get不能set，

　　或相反，但如果是public就不行了。另外我们可能并不想对属性进行写操作，这个时候，可以直接不写set方法。这就是只读属性了。

2、通过4种访问权限修饰符隐藏了类或者方法

java继承性：extends

1、子类继承父类后，父类中声明的属性、方法，子类就可以获取到。

2、子类除了通过继承，获取父类的结构之外，还可以定义自己特有的成分。

3、java中的类只支持单继承，不支持多继承。

4、由于Object是所有类的超类，那么你在最顶层的父类其实还会调用Object的无参构造函数。

子类对象实例化的全过程

 public class Main {
     public static void main(String[] args) {
         Dog dog = new Dog();
         dog.setAge(10);
         dog.setName("花花");
         dog.setHostName("小明");
         System.out.println("age:" + dog.getAge() + "\nname:" + dog.getName() + "\nhostname:" + dog.getHostName());
     }
 }
 //生物
 class Creator{
     private int age;
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
 }
 //动物
 class Animal extends Creator{
     private String name;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
 }
 //狗
 class Dog extends Animal{
     private String hostName;
     public String getHostName() {
         return hostName;
     }
     public void setHostName(String hostName) {
         this.hostName = hostName;
     }
 }

子类对象的实例化并没有在堆中创建了任何它的父类对象，只是把父类对象的属性带了过来。

 java多态性

多态性：可以理解为一个事物的多种表现形态。

1、方法的重载与重写
　　同一类中方法名相同，但是调用子类和父类的表现却是不同的。

2、子类对象的多态性

Person p = new Student(); //子类对象的多态性，父类的引用指向子类对象
//虚拟方法调用：实际调用子类重写父类的方法，但是父类必须有此方法声明
p.eat();
p.walk();

3、向下转型和向上转型

Person p = new Student();//向上转型
Student s = (Student)p;//向下转型，强制类型转换

　　但是这种转型是有一些风险的，那么最好用instanceof来判断

4、子类对象的多态性，并不适用属性。加入父类和子类的属性值相同，左边是谁，就使用谁的属性。

匿名类对象：

1、创建类的对象是没有名字的。

2、使用场景：当我们只需要调用一次类的对象时。

3、特点:创建的对象调用完一次这个对象就销毁了。

new Person().getName;

关键字：

1、this

this表示当前对象，用来修饰属性、方法、构造器

在构造器内部，this必须声明在首行。

class Cake{
    private String name;
    public Cake(){
        System.out.println("cake");
    }
    public Cake(String name){
        this();//this调用无参的构造器
        this.name = name;//this调用当前对象
    }
}

2、super

this表示父类对象，用来修饰属性、方法、构造器

在构造器内部，supper必须声明在首行。

在构造器内部，子类构造器都默认第一步调用父类无参的构造器，除非你加了this，因为只要加了this的话super就不起作用了。

 class Person{
     public Person(){
         System.out.println("p1");
     }
     public Person(int id,String name){
         this();
         System.out.println("p2");
     }
 }
 class Student extends Person{
     public Student(){
         System.out.println("s1");
     }
     public Student(String n){
         System.out.println("s2");
     }
     public Student(int g){
         this("s");
         System.out.println("s3");
     }
 }
 public class Main {
     public static void main(String[] args){
         Student student = new Student(0);
     }
 }

输出结果：p1 s1 s2

总结：

　　① 在构造器内要么用this要么用super,用了this，super就会失效。

　　② 在构造器内如果子类不显式的调用父类的构造器，那么默认调用无参的super();

　　③ 设计父类的时候，如果不显式的声明一个无参的构造函数，那么有可能造成程序编译错误。

3、static

静态的，可以修饰属性、方法、代码块、内部类

1）属性（类变量）：

class SportsMan {
    String name;
    int age;
    static String nation;
    public SportsMan(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
}

　　

总结：

　　① SportsMan类中的nation属性是static修饰的，由这个类创建的对象都共用这个属性。

　　② 类变量的加载早于对象，所以既可以用“sp1.nation”，也可以用“SportsMan.nation”调。

　　③ 当其中一个对象对此类变量进行修改，会影响其他对象的类变量的一个调用。

　　　　

2）方法：

　　① 随着类的加载而加载，在内存中也是独一份。

　　② 可以直接通过“类.类方法”

　　③ 静态方法内部可以调用静态的属性或者方法，但是不能调用非静态的属性和方法，因为静态的生命周期要早于非静态对象。

　　④ 非静态的方法可以调用静态的属性和方法，因为非静态的方法晚于静态的方法和属性。

4、final

　　① 修饰类 ：不能被继承

　　② 修饰方法：不能被重写

　　③ 修饰属性：此属性就是一个常量。此常量不能使用默认初始化（除非在构造器中或者非静态代码块初始化），可以显式的赋值。

     final int I;// 编译错误
     final int I = 12;//正确
     public void m(){
         I = 15; // 编译错误
     }

　　但是如果放在构造器中，就没问题。

     final int I;//正确
     public A(){
         I = 15;//正确
         System.out.println("3");
     }

笔试题一：

 public class Something{
 　　public int addOne(final int x){
 　　　　return ++x;
 　　}
 }

　　肯定编译错误，final一旦修饰的时候赋了值，那么对不起，我的值就是最终的值，以后谁都不能改，谁改谁错。

笔试题二：

 public class Something{
 　　public static void main(String[] args){
 　　　　Other o = new Other();
 　　　　new Something.addOne(o);
 　　}
 　　public void addOne(final Ohter o){
 　　　　o.i++
 　　}
 }
 class Other{
 　　public int i;
 }

　　肯定不出错，final修饰的是o（即o的堆地址），o里的属性没关系，想怎么变就怎么变。

类的成员之四：初始化块

1）非静态块

 class Person{
     int id = 0;
     String name = "n";
     {
         id = 10;
         name = "ni";
         System.out.println("你好：你");
     }
     {
         id = 11;
         name = "hao";
         System.out.println("你好：好");
     }
     public Person(){
         id = 12;
         name = "ni hao";
     }
 }
 public class Main {
     public static void main(String[] args) {
         Person p1 = new Person();
         System.out.println(p1.id + "\n" + p1.name);
     }
 }

输出结果：

　　你好：你
　　你好：好
　　12
　　ni hao

① 可有对类的属性（静态和非静态）进行初始化操作

② 里面可以有输出语句

③ 属性赋值的顺序：默认初始化值--->显式初始化或者代码块初始化（此处看顺序位置）--->构造器--->通过setter方法

2）静态块

① 随着类的加载而加载，而且只被加载一次。

② 静态的代码块在非静态代码块之前运行

③ 非静态的属性不能放在静态代码块

笔试题：

 class A{
     static {
         System.out.println("1");
     }
     {
         System.out.println("2");
     }
     public A(){
         System.out.println("3");
     }
 }
 class B extends A{
     static {
         System.out.println("a");
     }
     {
         System.out.println("b");
     }
     public B(){
         System.out.println("c");
     }
 }
 public class Main {
     public static void main(String[] args) {
         A a = new B();
         a = new A();
     }
 }

输出结果：1 a 2 3 b c 2 3

总结：

　　① 不管是静态代码块还是非静态代码块都是从父类开始执行的。

　　② 静态代码块只执行一次，非静态代码块new一次执行一次。

抽象类：

1、抽象类

　　① 抽象类不能被实例化

　　② 抽象类可以有构造函数

　　③ 抽象方法所在的类一定是抽象类

　　④ 抽象类中可以没有抽象方法

　　⑤ 不能和final共同修饰类

2、抽象方法

　　① 抽象方法必须需要子类进行重写

　　② 抽象类中可以有具体的实现方法。

　　③ 若子类是一个具体的“实体类”，那么就必须实现继承抽象类中的所有的抽象方法

　　④ 若子类继承抽象类，没有重写完所有的抽象方法，那么此类必须也是一个抽象类

3、其他：abstract不能修饰属性、构造器、private、final、static

　　① abstract 不能修饰属性，因为子类的属性是无法重写父类属性的

　　② abstract 不能修饰构造器，因为构造器不能被重写

　　③ abctract 不能和private修饰，因为你本来就是想让子类进行重写的，private的话你还让子类怎么重写。

　　④ final就不用说了，它修饰的方法不能被重写。它两个本身就是矛盾的。

　　⑤ static的话，直接用类.方法调用时不合规的。

 abstract class Animal {
     public Animal(){
         // 只要实例化子类，抽象类的构造器会被执行。
         System.out.println("我是一个抽象动物");
     }
     public void breath(){
         //抽象类中可以有具体实现方法。可以通过实例化子类，再调用抽象类的方法。
         System.out.println("动物都会呼吸");
     }
     public abstract void cry();
 }

 class Cat extends Animal{

     @Override
     public void cry() {
         System.out.println("猫叫：喵喵...");
     }
 }

 class Dog extends Animal{

     @Override
     public void cry() {
         System.out.println("狗叫:汪汪...");
     }

 }
 public class Main {
     public static void main(String[] args) {
         Animal cat = new Cat();
         cat.cry();
     }
 }

执行结果：

　　我是一个抽象动物
　　猫叫：喵喵...

 接口

　接口是一个特殊的抽象类，只有两个元素①常量 ②抽象方法

　1、接口不需要写权限修饰符，肯定是public。

2、常量默认使用public static final修饰，方法默认使用public abstract修饰

　3、接口既不能实例化，也不能有构造器

　4、如果实现接口，那么就需要实现接口的所有抽象方法

　5、接口之间可以多继承

　6、类可以实现多个接口，但是需要实现这些接口所有的抽象方法。

 public class DayStudy {
     public static void main(String[] args) {
         //1、第一个多态性。格式：接口 参数 = new 实现类()
         Runner d = new Duck();
         test1(d);
         //2、第二个多态性。参数用接口类型，传入实现类，解耦
         Duck d1 = new Duck();
         test1(d1);
         test2(d1);
         test3(d1);
     }
     public static void test1(Runner r ){
         r.run();
     }
     public static void test2(Swiner s ) {
         s.swin();
     }
     public static void test3(Flier f ) {
         f.fly();
     }
 }
 interface Runner{
     void run();
 }
 interface Swiner{
     void swin();
 }
 interface Flier{
     void fly();
 }
 class Duck implements Runner,Swiner,Flier{
     @Override
     public void run() {
         System.out.println("会跑");
     }
     @Override
     public void swin() {
         System.out.println("会下水游泳");
     }
     @Override
     public void fly() {
         System.out.println("会飞");
     }
 }

接口匿名类 ：接口 参数 = new 接口(){ 这里面具体把接口的抽象类实现 }

Runner r = new Runner(){
　　@override
　　public void run(){
　　　　system.out.printLn("匿名类");
　　}
}