day10遇见狂神说学Java

封装

高内聚，低耦合，该漏的漏，该藏的藏

高内聚，低耦合的意思是如银行来举例，高内聚：只允许银行内部人员对钱进行操作，不允许外部人员干涉；低耦合：仅暴露少量的方法给外部人员使用，用户只能对自己的钱进行存取操作。

封装中，属性私有，get/set。将属性private后，那么外部不可以对这个属性直接进行读取、修改，只能通过set、get进行访问。public将控制权可以交给别人，但是private是将控制权留给自己。

1.提高程序的安全性，保护数据

2.隐藏代码的实现细节

3.统一接口

4.增加系统可维护性

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.setAge(-1);
        System.out.println(student.getAge());
        student.setName("秦将");
        System.out.println(student.getName());
    }
}
public class Student{
    //属性私有：封装的特性，私有属性后，通过开发人员的编写，在用户层面，用户只能进行适当的权限操作，从而保护了数据信息。
    private int age;
    private String name;
    //由于此时属性私有，那么别的类就不能随意调用这个方法，此时就需要公开的public中set/get方法进行属性调用
    //get方法是获取该属性的值，set方法是对该属性进行赋值
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>120|age<0) {
            this.age=3;
        }else {
            this.age=age;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

继承

继承是类和类之间的关系，父类(基类)，子类(派生类)

子类要继承父类，需要使用extends关键字表示，子类是父类的扩展。

在Java中，所有的类都直接或者间接继承Object类

Java中类只有单继承，没有多继承。比如一个儿子只有一个爸爸，但是一个爸爸可以有多个儿子

public class Person {
    private int age;
    String name;
    int money=10_0000_0000;
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void say(){
        System.out.println("说了一句话");
    }
}
public class Teacher extends Person {
    public static void main(String[] args) {
        Person teacher= new Person();
        teacher.setAge(15);
        System.out.println(teacher.getAge());
        teacher.say();
        System.out.println(teacher.money);
    }
}

super–代表父 this–代表当前

super只能在子类的构造方法或者方法中出现；

super在构造方法中，必须写在第一个；

super和this不能同时调用构造方法；

和this的不同：

1.this只能在本类中调用，而super必须在继承条件下才能调用

2.this表示本类的；super表示父类的

package OOP.Demo09;

import OOP.Demo09.Student;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.test("秦将");
    }
}
public class Student extends Person{
    private String name="狂神";

    public Student() {
        //不调用父类的无参，也会隐藏执行；先执行父类的无参，再执行子类；
        //如果父类是有参构造，那么在调用时，也只能调用有参构造
        super("hhhhh");
        System.out.println("student无参执行");
    }

    public void print(){
        System.out.println("hhhh");
    }
    public void test1()//有static不能用this
    {
    print();
    super.print();
    }
    public void test(String name)//有static不能用this
{
    System.out.println(name);
    System.out.println(this.name);
    System.out.println(super.name);
}
}
public class Person {
    public Person(String construct) {
        System.out.println("person 无参执行");
    }

    protected String name="秦将";
    public void print(){
        System.out.println("Person");
    }
}

方法的重写

public class Application {
    public static void main(String[] args) {
        A a=new A();
        a.test();
        B b=new A();//static：父类的引用指向子类；静态方法调用时，方法的调用只和左边定义的数据类型有关，比如左边是A，结果就为a//去掉static：子类重写了父类的方法
        
        b.test();

    }
}
public class A extends B {
    @Override
    public void test() {
        super.test();
    }
}
public class B {
    public void test(){
        System.out.println("B->test");
    }
}

总结：重写用于父类的东西子类，想要改变，重写需要在继承关系下使用；

static不能用作方法的重写，因为static是和类开始同时创建的

1.重写只用于方法，不用于属性；

2.重写方法名、参数，返回类型需保证一样；

3.修饰符范围可以扩大，但不能缩小；

4.重写抛出异常的范围可以缩小，但不能扩大；比如父类有100万欠款，不能到子类就有1000万

方法重载：相同的方法名，但是返回类型和参数均不一样

多态

public class Application {
    public static void main(String[] args) {
       Person s1 =new Student();//只能是子类和父类的关系时，才可以让父类的引用指向子类
       Student s2 =new Student();

       s1.run();
       s2.run();//子类重写了父类的方法，父类调用的也是子类
       s2.eat();//父类不能调用子类独有的方法
        //总结：对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
    }
}
public class Person {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends Person{
    public void run(){
        System.out.println("walk");
    }
    public void eat(){
        System.out.println("eat");
    }
}

总结：

1.多态一定要有继承关系

2.父类的引用指向子类

3.子类重写父类的方法