java笔记_面向对象

创建和初始化对象

构造器详解

• 和类名相同
• 没有返回值
• 定义有参构造后, 必须显式定义无参构造

封装

• private:属性私有
• get/set

继承(extends)

• 在Java中, 所有的类, 都直接或间接的继承Object
• 子类会继承父类的属性和方法, 但是父类的private属性不能继承
• 子类构造器默认且强制地先执行父类的无参构造器(不手动调用父类有参)
• super调用父类

方法重写

• 父类的应用可以指向子类

// fa是父类, son是字类
fa temp = new son();

• 方法的调用只跟本身的类型有关(对于静态方法来说, 静态方法不会被重写)
• 只有非静态且public方法可以被重写
• 子类重写父类的方法
• 方法重写小结:
  • 需要有继承关系, 子类重写父类的方法
  • 方法名和参数列表必须相同
  • 修饰符:范围可以扩大但不能缩小: public > protected > default > private
  • 抛出的异常:范围可以缩小不能扩大: ClassNotFoundException --> Exception(大)

多态

• 多态的存在条件是: 继承关系, 重写方法, 父类引用指向子类对象
• 对象能执行的方法, 看本身的类型, 具体的方法看new的类型
• static, private, final没有多态

instanceof和类型转换

//Object > String
//Object > Person > Teacher
//Object > Person > Student
Object temp1 = new Student();
temp1 instanceof Student //true
temp1 instanceof Person //true
temp1 instanceof Object //true
temp1 instanceof Teacher //false
temp1 instanceof String //false
Person temp2 = new Student();
temp2 instanceof Student //true
temp2 instanceof Person //true
temp2 instanceof Object //true
temp2 instanceof Teacher //false
temp2 instanceof String //无法编译

• 父类转子类是强转

//Person > Student
Student temp1 = new Student();
Person temp11 = temp1;
Person temp2 = new Person();
Student temp22 = (Student) temp2;

static详解

package com.cen.oop;

public class demo02_static {

    {
        // 匿名代码块
        System.out.println("匿名代码块");
    }

    // 只执行一次
    static {
        // 静态代码块
        System.out.println("静态代码块");
    }

    public demo02_static(){
        System.out.println("构造器");
    }

    public static void main(String[] args) {
        demo02_static temp1 = new demo02_static();
        System.out.println("=====");
        demo02_static temp2 = new demo02_static();
    }
}
/**
 * 输出:
 * 静态代码块
 * 匿名代码块
 * 构造器
 * =====
 * 匿名代码块
 * 构造器
 */

静态导入包

import static java.lang.Math.random;

抽象类(abstract)

• 抽象类可以有抽象方法(public abstract)和具体方法
• 抽象类中有构造方法
• 抽象类不能new
• 抽象方法只能写在抽象类中

接口(interface)

• 接口中的定义都是抽象的(public abstract), 常量(public static final)
• 接口可以多实现(implements)
• 接口没有构造方法, 也不能被实例化
• 接口的方法必须要重写

内部类

• 成员内部类

package com.cen.oop;

class Outer{
    public void out()
    {
        System.out.println("这是外部类的方法");
    }
    class Inner{
        public void in()
        {
            System.out.println("这是内部类的方法");
        }
    }
}

public class demo3 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类实例化内部类
        Outer.Inner inner = outer.new Inner();
        outer.out();
        inner.in();
    }
}

• 静态内部类

package com.cen.oop;

class Outer{
    public void out()
    {
        System.out.println("这是外部类的方法");
    }
    static class Inner{
        public void in()
        {
            System.out.println("这是内部类的方法");
        }
    }
}

public class demo3 {
    public static void main(String[] args) {
        //Outer outer = new Outer();
        //通过外部类实例化内部类
        new Outer.Inner().in();
    }
}

• 局部内部类

package com.cen.oop;

class Outer{
    public void out() {
        System.out.println("这是外部类的方法");
        class Inner {
            public void in() {
                System.out.println("这是内部类的方法");
            }
        }
    }
}

public class demo3 {
    public static void main(String[] args) {
       
    }
}

• 匿名内部类

package com.cen.oop;

class temp1{
    public void out() {
        System.out.println("class");
    }
}
interface temp2{
    void hello();
}
public class demo04 {
    public static void main(String[] args) {
        new temp1().out();
        temp2 tt2 = new temp2() {
            @Override
            public void hello() {

            }
        };
    }
}

参考

遇见狂神说. 【狂神说Java】Java零基础学习视频通俗易懂