10封装与继承

1、封装

//  1、良好的封装能够减少耦合
//  2、类内部的结构可以自由修改
//  3、可以对成员进行更精确的控制
//  4、隐藏信息，实现细节

2、实现封装

//第一步：将属性修改可见性从之前的默认或者共有修改为私有
//第二步：加入getter/setter方法
//第三步：在我们的getter/setter方法中增加上逻辑语句
public class Dog {
    //第一步：将属性修改可见性从之前的默认或者共有修改为私有
    private String name;
    //第一步：将属性修改可见性从之前的默认或者共有修改为私有
    private int age;
    //第二步：加入getter/setter方法
    public String getName(){
        return name;
    }
    //第二步：加入getter/setter方法
    public void setName(String name){
        this.name=name;
    }
    //第二步：加入getter/setter方法
    public int getAge(){
        return age;
    }
    //第二步：加入getter/setter方法
    public void setAge(int age){
        //第三步在我们的getter/setter中增加上逻辑语句
        if(age<=0||age>=15){
            System.out.println("对不起，你输入的不是一只狗可以承受的年龄，建议重新输入 佛祖额使用默认值：2");
            this.age=2;
        }else{
            this.age=age;
        }
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

get是获取值 set是设置值

对象代码：
        public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setAge(128);
        dog.setName("小白");
        System.out.println(dog);
    }

3、关于导包

import java.util.*;

此时导入的是Java.util包中所有类

而不是把整个java.util包导入

这两句话区别就在于一个是只提到类，另一句把包下的包也提到了，但是导入*是只导入类，不导入包下的包。

4、访问修饰符

访问修饰符/关系	类内	包内（不考虑父子）	父子（非同包）	其他
public	可	可	可	可
protected	可	可	可
default(不写的，默认的)	可	可
private	可

private是一个权限修饰符，用于修饰成员（变量、方法），被修饰的成员只能在本类中调用，也可以用set/get方法进行调用，此时就可以在set/get中加入选择、判断等逻辑语句用于控制输入值的合法性。

5、继承-extends

public class Dog extends Pet {
    private String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }
}

public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    
public class Pet {
    private String name;
    private int health;
    private int love;

    public String getName() {
        return name;
    }

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

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }
}
}public class Test00 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setHealth(100);
        dog.setStrain("金毛");
        Penguin pen = new Penguin();
        pen.setName("马达加斯加的企鹅");
        pen.setHealth(99);
        System.out.println("这只狗的名字叫：" + dog.getName() + "，健康值是：" + dog.getHealth()+"，品种是："+dog.getStrain());
        System.out.println("这只企鹅的名字叫：" + pen.getName() + "，健康值是：" + pen.getHealth());
    }
}

在Java中，任何类如果没有继承类（没有用到extends关键字）那么他会自动继承Obj类

所以说Java中所有的类都直接或者间接的继承了Object类，也可以说所有类都继承了Object类。因为间接继承也是继承。

比如你继承了某个类，那这个类只有两个可能，1、继承了某个类，2，继承了Object，如果2，那你继承了Object类，如果1，那那个类可能也继承了某个类，这个某个类只有两种可能，1、继承了某个类，2，继承了Object，一直循环，直到没有继承，继承Object类。

Object就是对象，所以Java中说”万物皆对象“。

6、super关键字

super关键字和我们之前学习的this关键字非常相似。

父类也就是超类，我们使用super关键字表示超类信息

super.属性 方法

public class Dog extends Pet{
    //如果你使用Dog实例化对象，执行dog.show();
    //此时会执行dog的show方法，这个称之为方法的重写
    public void show(){
        //这里可以调用到超类的name属性
        //但是要注意，当前属性的访问修饰符
        System.out.println(super.name);
        System.out.println("这是一只狗");
    }
    public void show1(){
        //由于show被重写，所以如果你直接写show();
        //那么调用的会是被重写的那个show();
        //若你想要使用我们的超类的show方法，我们需要使用super关键字
        super.show();
    }
}

public class Pet{
    public void show(){
        System.out.println("这是一只宠物");
    }
}

super();

public class Dog {
    public Dog(String name, String strain) {
        //这个方法和this();几乎一样
        //super();只能出现在代码的第一行
        //所以，我们的构造方法无法同时使用super()和()
        //只能二选一
        super(name);
        this.strain = strain;
    }
}

public class Pet {
    public Pet(String name) {
        this.name = name;
    }
}

7、static关键字

static关键字是 静态

被static关键字修饰的内容不再属于他的对象，而是属于这个类本身。

7.1成员变量

public class A {
    public static  int num =100;
}
public class T2 {
    public static void main(String[] args) {
        A a1=new A();
        A a2=new A();
        A a3=new A();
        A a4=new A();
        A.num++;
        a1.num++;
        a2.num++;
        a3.num++;
        System.out.println(++a4.num);
        //最终结果为105  因为每一次调用该属性都是属于类的属性，大家都是相通的
    }
}

无论你是使用类去调用还是使用对象去调用其结果均为调用相同房存储部分。

7.2成员方法

注意事项：静态方法中不能使用this和super

​ 不能直接访问所属类的实例变量和实例方法

​ 可直接访问类的静态变量和静态方法

静态方法必须被实现

public class B{
    pbulic int num;
    
    public static int staticNum;
    
    public static void staticMethod(){
        System.out.println("这个静态方法被调用了");
        //我们无法直接在静态代码块中调用非静态的属性
        //Sytstem.out.println(num);
        //但是我们可以在静态代码块中调用到静态的属性
        System.out.println(staticNum);
        //也就是说，由于非静态的属性属于对象，但是我们这里属于类
        //我们可以直接通过类去调用，既然如此可能都不存在对象，肯定无法用到对象的属性
        B b=new B();
        //虽然无法直接调用非静态的属性
        //原因是因为没有对无法去调用
        //那么我们就能直接通过构造一个对象，来访问该属性
        System.out.printlnn(b.num)
            
        //我们可以直接调用静态方法
        staticMethod1();
        //同理，无法直接调用非静态的方法
        //method1();
        //一个道理，可以手动实例化对象调用该方法。
        b.method1();
    }
    
    public static void staticMethod1(){
        
    }
    
    public void method1(){
        
    }
}

public class Test09{
    public static void main(String[] args){
        //这类方法，我们一般不需要去实例化
        //不需要实例化，我们省略了关于对象的创建
        //对于工具类方法我们使用类名直接调用会非常的方便
        B.staticMethod();
    }
}

7、3代码块

public class A{
    public A(){
        System.out.println("A类构造方法被调用了");
    }
    
    static{
        //首次加载这个类的时候，需要对这个类执行部分初始化内容。会用到这个
        System.out.println("A类被调用了！3");
    }
        static{
        //首次加载这个类的时候，需要对这个类执行部分初始化内容。会用到这个
        System.out.println("A类被调用了！2");
    }
        static{
        //首次加载这个类的时候，需要对这个类执行部分初始化内容。会用到这个
        System.out.println("A类被调用了！1");
    }
    
    public static void method(){
        System.out.println("method()方法被调用");
    }
}

    public static void main(String[] args){
        A.method();
        A a=new A();
        //A类被调用到了！！3
        //A类被调用到了！！2
        //A类被调用到了！！1
        //method()方法被调用
        //A类构造方法被调用了
    }

我们可以发现A类的静态代码块在执行A类任何方法、构造方法之前执行，并且这个静态代码块只会执行一次，如果你存在多个静态代码块，会按照你写入的顺序进行加载。

一般而言，静态代码块是使用于我们这个类首次加载的时候进行初始化操作

7、4static静态代码执行的顺序

public class A{
    public A(){
        System.out.println("A类的构造方法");
    }
    static{
        System.out.println("A类的静态代码块");
    }
}

public class B extends A{
    public B(){
        System.out.println("B类的构造方法");
    }
    static{
        System.out.println("B类的静态代码块");
    }
    public static void staticMethod1(){
        System.out.println("B类的静态方法method1");
    }
    public void method1(){
        System.out.println("B类的方法method1");
    }
}

public class Test{
    public static void main (String[] args){
        //由父及子，静态先行
        
        /**
        *A类的静态代码块
        *B类的静态代码块
        *A类的构造方法
        *B类的构造方法
        *B类的方法method1
        */
        
        B b= new B();
        b.method1();
        //A类的静态代码块块（只执行一次）
        //B类的静态代码块（只执行一次）
        //B类的静态方法method1
        B.staticMethod1();
    }
}