JAVA面向对象 笔记整理③

JAVA零基础部分笔记

1.方法重写

重写：需要有继承关系，子类重写父类的方法！

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大：public>protected>default>private

4.抛出的异常：范围，可以被缩小，但不能被扩大；

重写，子类的方法和父类方法名必须要一致；方法体不同！

为什么需要重写：

1.父类的功能，子类不一定需要，或者不一定满足！

重写的快捷键：Alt+Insert;：override;

静态方法和非静态方法的区别很大，不要随意去写静态方法

重写是对非静态方法的，没有静态方法的重写

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//B
    }
}

public class A extends B {//子类 A
    //Override 重写
    @Override //注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}

//重写都是方法的重写，与属性无关
public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

结果 ：A=>test()

​ A=>test()

2.多态

多态：即同一方法可以根据发送对象的不同而采取多种不同的行为方式。

一个对象的十几类型是确定的，但可以指向对象的引用的类型有很多

多态注意事项：

1.多态和方法的多态，属性没有多态

2.父类和子类，有联系 类型转换异常！ ClassCastException!

3.存在条件：继承关系，方法需要重写，父类引用指向子类对象!

​ Father f1 = new Son();

public class Application {
   public static void main(String[] args) {
       //一个对象的实际类型是确定的
       //new Student()；
       //new Person();

       //可以指向的引用类型就不确定了；父类的引用指向子类

       //Student 猛调用的方法都是自己的或者继承父类的！
       Student s1 =new Student();
       //Person 父类型，可以指向子类，但是不能调用子类独有的方法
       Person s2 = new Student();

       //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
/*强制转换Person->Student 高转低 */ ((Student)s2).eat();//子类重写了父类的方法，执行了子类的方法
       s1.eat();
       s1.run();
       s2.run();
   }
}

public class Person{//父类
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person{//子类
    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

结果：eat

​ eat

​ son

​ son

3.instanceof和类型转换

​ instanceof （类型转换） 引用类型，判断一个对象是什么类型

​ instanceof关键字可以判断左边对象是否是右边类或者子类的一个实例

判断

 public static void main(String[] args) {
        // Object > Person > teacher
        // Object > Person > Student
        // Object > String
        Object o = new Student(); // 主要看这个对象是什么类型与实例化的类名
        // instanceof关键字可以判断左边对象是否是右边类或者子类的一个实例
        System.out.println(o instanceof Student); // o 是Student类的一个实例对象 所以判断右边类跟student有无关系 以及显示声明有无关系
        System.out.println(o instanceof Person); // true
        System.out.println(o instanceof Object); // true
        System.out.println(o instanceof String); // false
        System.out.println(o instanceof Teacher); // 无关系

        Person person = new Student();
        System.out.println(person instanceof Person); // true
        System.out.println(person instanceof Object); // true
        // System.out.println(person instanceof String); // 编译错误
        System.out.println(person instanceof Teacher); // 无关系
    }

结果：true \n true \n true \n false \n false \n true \n true \n false

类型之间的转换

public class Application2 {
    public static void main(String[] args) {
        //类型之间的转换：父 子

        //高              低
        Person student = new Student();
        //student将这个对象转换为student类型，我们就可以使用student类型的方法了！

        ( (Student) student).go();//将 student 从Person类型转换为 Student类型
    }
}

public class Student extends Person{//子类
    public void go(){
        System.out.println("go");
    }

public class Person {//父类
    public void run(){
        System.out.println("run");
    }
}

结果：go

4.static

静态块（static{}）
（1） static关键字还有一个比较关键的作用，用来形成静态代码块（static{}( 即static块)）以优化程序性能。

（2） static块可以置于类中的任何地方，类中可以有多个static块。

（3） 在类初次被加载的时候执行且仅会被执行一次（这是优化性能的原因！！！），会按照static块的顺序来执行每个static块，一般用来初始化静态变量和调用静态方法。

public class Person {
    //2：赋初始值
    {
        System.out.println("匿名代码块");
    }
    //1:只执行一次
    static{
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        new Person();
        System.out.println("========");
        Person person1 = new Person();
    }
}

结果：静态代码块

匿名代码块

构造方法

=======

匿名代码块

构造方法

5.抽象类 abstract

存在的意义：提高开发效率

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

抽象类，不能使用new 关键字来创建对象，它是用来子类继承的。

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

抽象类中可以写普通的方法

package Demo04;
//abstract 抽象类：类  extends：单继承！   (接口可以多继承)
public abstract class Acation {
    //约束~有人帮我们实现~
    //abstract 抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现它：约束
    //2.抽象类里可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象
}
==============================================
    //抽象类的所有方法，继承了他的子类，都必须要实现他的方法！
public class A extends Acation{
    @Override
    public void doSomething() {
        
    }
}