【JAVA基础学习笔记9】

封装

高内聚，低耦合

• 一般禁止直接对象数据的实际表示，而是通过接口进行访问
• 属性私有，同get/set操作属性

//1.先创建一个类
public class Student {
    //属性名私有
    private String name;
    private int age;
    //提供操作属性的方法 alt+insert
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>110||age<0){
            this.age = 3;
        }else{
            this.age = age;
        }

    }
}


//2.对封装类进行操作
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("kim");
        System.out.println(student.getName());//kim
        student.setAge(5);
        System.out.println(student.getAge());//5
    }

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

• 子类继承父类用的关键字：extends
• 一个子类只能直接继承一个父类
• ctrl+H 可以查看继承关系(任何类都会继承object类)

//父类
public class Person {
    int money = 1000;
    public void play(){
        System.out.println("playing!");
    }
}

//学生 is  人  ：是人的子类
//子类继承父类，就会拥有父类的全部方法
public class Student extends Person{

}

//调用现实
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.money);  //1000
        student.play();  //playing!
    }
}

1.super关键字在继承中的使用

//父类
public class Person {
    int money = 1000;
    protected String name = "person-kim";
    public void print(){
        System.out.println("person");
    }
}
//学生 is  人  ：是人的子类
//子类继承父类，就会拥有父类的全部方法
public class Student extends Person{
    private String name = "student-kim";
    public void print(){
        System.out.println("student");
    }
    public void test1(){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
        System.out.println("===================");
        print();
        this.print();
        super.print();
    }
}
//调用
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test1();
    }
}

//结果
student-kim
student-kim
person-kim
===================
student
student
person

• 子类调用了父类的无参构造器(可以省略，如果要写，父类构造器必须放在子类构造器第一行)

2. super使用的注意点

• 1.super调用父类的构造方法，必须在构造方法的第一个
• 2.super必须只能出现在子类的方法或构造方法中
• 3.super和this不能同时调用构造方法
• 4.super和this区别：
  • 代表的对象不同：super代表父类对象的引用；this代表本身调用这个对象
  • 使用条件不同：this不使用继承时也可以使用；super只能在继承条件下使用
  • 构造方法不同： this()；本类的构造；super()；父类的构造

3.方法重写

• 方法重写必须要有继承关系，子类重写父类的方法。非静态且公开的方法才叫重写
• 方法名必须相同
• 参数列表必须相同
• 修饰符范围可以扩大但不能缩小
• 抛出的异常范围可以缩小但不能扩大
• 重写时，子类和父类必须要一致
• 快捷键：alt+insert override

//父类
public class Person {
    int money = 1000;
    protected String name = "person-kim";
    public void print(){
        System.out.println("person");
    }
}
//学生 is  人  ：是人的子类
//子类继承父类，就会拥有父类的全部方法
public class Student extends Person{
    private String name = "student-kim";
    public void print(){
        System.out.println("student");
    }
}
//调用
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
         student.print();
        //父类的引用指向了子类
        Person person = new Student(); //子类重写了父类方法
        person.print();
    }
}

//结果
student
student

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

• 多态存在的条件
  • 有继承关系
  • 子类重写父类的方法
  • 父类引用指向子类的对象
• 多态是方法的多态，属性没有多态
• 不能重写的：static方法属于类，不属于实例；final常量；private

//父类
public class Person {
    public void play(){
        System.out.println("person-play");
    }
}
//子类
public class Student extends Person{
    @Override//重写
    public void play() {
        System.out.println("student-play");;
    }
    //父类没有的方法
    public void run(){
        System.out.println("student-run");
    }
}
//举例
public class Application {
    public static void main(String[] args) {
        //Student 子类能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型可以指向子类，但不能调用子类独有的方法
        Person  s2 = new Student();
        Person  s3 = new Person();

        s1.play();//子类重写了父类方法，执行子类方法
        s2.play();
        s3.play();

        s1.run();
        //s2.run();  //会报错

    }
}

//结果
student-play
student-play
person-play
student-run

instanceof

• 父类引用指向子类的对象
• 把子类转换为父类，向上转型
• 把父类转换为子类，向下转型，需要强制转换
• 还可以用来判断是否存在父子关系

//父类
public class Person {
    public void play(){
        System.out.println("person-play");
    }
}
//子类
public class Student extends Person{
    @Override//重写
    public void play() {
        System.out.println("student-play");;
    }
    //父类没有的方法
    public void run(){
        System.out.println("student-run");
    }
}
//举例
public class Application {
    public static void main(String[] args) {
        //Student 子类能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型可以指向子类，但不能调用子类独有的方法
        Person  s2 = new Student();
       ((Student) s2).run();//将s2的Person类型强制转换为Student类型，后就可以调用Student类的方法
       System.out.println(s2 instanceof Student);
        System.out.println(s2 instanceof Person);
        System.out.println(s2 instanceof Object);
    }
}

//结果
student-run
true
true
true

static关键字

• static只执行一次，对象一创建就会执行

//测试代码
import static java.lang.Math.random;//静态导入包
public class DemoStatic {
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }

    public DemoStatic() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        new DemoStatic();
        System.out.println("=============");
        new DemoStatic();
         System.out.println(random());//因为添加了静态导入包
                                  //直接写random() 而不用 math.random()
    }
}
//结果
静态代码块
匿名代码块
构造方法
=============
匿名代码块
构造方法