Java--面向对象_中

封装

使用private关键字去修饰变量和方法，使变量和方法只能够在本类当中使用，但他会给本类提供接口，让其他类来间接访问本类当中的数据。

public class Animal{
    private String name;
    private int age;

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

    public String getName(){
        return name;
    }

    public void setAge(int age){
        if (age<0){
            System.out.println("error");
        }else{
            this.age=age;
        }

    }

    public int getAge(){
        return age;
    }


    public  void introduce(){
        System.out.println("我叫"+name+"今年"+age);
    }

    public static void main(String[] args){
        Animal dog=new Animal();
        dog.setAge(-18);
        dog.setName("daHuang");
        dog.introduce();
    }
    
}

继承

注意：
子类拥有父类除 private 以外的所有属性和方法（就是代码）。
子类可以拥有自己的属性和方法。
子类可以重写实现父类的方法。
Java 中的继承是单继承，一个类只有一个父类。

语法格式
class 子类 extends 父类{}

public class Animal {
public int legNum;     //动物四肢的数量
//类方法
public void bark() {
    System.out.println("动物叫！");
}
}

//Dog类继承Animal类
public class Dog extends Animal {
}

public class Test{
public static void main(String[] args) {
    Dog a = new Dog();
    a.legNum = 4;
    a.bark();
}
}

多态

抽象类

抽象类定义：
1.抽象类和抽象方法必须都有abstract
2.抽象类不能被实例化，也就是不能new关键字去产生对象。
3.抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
注意：
抽象类当中可以有普通方法和抽象方法。
抽象方法
抽象方法就是在方法的前面加上 abstract，他也有普通方法的功能和属性。
其父类必须是抽象类（再类名前面加上abstract），继承的子类必须重写父类中的抽象方法。

接口

接口用于描述类所具有的功能（就是更加抽象的类），而不提供功能的实现。
接口语法：

 修饰符 interface A extends 接口1，接口2{  
     
     public  static  final 数据类型 成员名称 = 常量； //数据成员必须赋初值，其中public static  final 可以不写
     
     abstract 返回值的数据类型 方法名称(参数..); //抽象方法，注意在抽象方法里，没有定义方法主体
     default 返回值的数据类型 方法名称(参数..){}
     static 返回值的数据类型 方法名称(参数...){}
     
     }

以上方法都有public都可以默认不行，会自动添加。

访问接口：
全局常量：实现类.常量
静态方法：接口名.方法名
抽象方法和默认方法 ： 通过接口 的实现类 的对象来访问
注意：
implements实现接口，并实现接口中的全部抽象函数。其中实现的类必须把接口中的方法全都去重写。

接口的实现：

    class 类名称 [extends  父类名] implements 接口A,接口B 
{
    ...
}

接口不能用于实例化对象。

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

        System.out.println(dogName.ID);//全局常量获取:实现类.

        dogName daHuang=new dogName();
        daHuang.breathe();   //抽象函数获取:实现类对象.

        daHuang.getType("金毛"); //默认函数获取：实现类对象.

        System.out.println(Dog.getID()); //静态函数获取:接口名.

    }
}

多态

多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态
Animal a = new Animal(); //a是父类的引用指向的是本类的对象
Animal b = new Dog(); //b引用的数据类型和对象的数据类型不一致
为啥会出现多态？
b调用方法的时候实际调用的是Dog()重写后的方法
多态条件
1、b是父类的引用指向的是子类的对象
2、调用的方法有重写

 public class Dog {
    public void blak(){
      System.out.println("wangwang");
  }
}
 public class Animal extends Dog{
     String name;
     int age;
    public  void blak(){
        System.out.println("动物叫");
    }

    public static void main(String[] args){
        Dog daHuang=new Animal();
        daHuang.blak();//动物叫
    }

}

内部类

非静态类

非静态内部类可以直接在一个类里面定义

public class Animal{
    private String name;
    float hp;
    String blak;

    // 非静态内部类，只有一个外部类对象存在的时候，才有意义
    class BattleScore{
        int kill;
        int die;
        int assit;
        public  void legendary(){
            if(kill>=8)
                System.out.println(name+"咬了");
            else
                System.out.println(name+"被咬了");
        }
    }

    public  static void main(String [] args){
        Animal dog=new Animal();
        dog.name="daHuang";

        // 实例化内部类
        BattleScore score=dog.new BattleScore();
        score.kill=9;
        score.legendary();
    }

}

调用方式：父类引用.子类对象
如 dog.new BattleScore();

静态内部类

静态内部类 不需要一个外部类的实例为基础，可以直接实例化

语法：new 外部类.静态内部类();

因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法

访问静态内部类的类方法和实例方法

public class Main {
    
    static class InnerClass{
        public static void m(){
            System.out.println("静态内部类方法");
        }
        
        public void m_1(){
            System.out.println("实例方法");
        }
    }

    public static void main(String[] args) {
        Main.InnerClass.m();

        Main.InnerClass mi= new Main.InnerClass();
        mi.m_1();
    }

    }

局部内部类

定义在方法中的类，有效范围在方法之中。
局部内部类可以访问外部类的所有成员和方法，但是内部类的成员和方法仅限于此方法中使用。

public class Animal{
    int m=1;
    void test1(){
        System.out.println("外部成员类方法");
    }
    void test2() {

        //定义局部内部类Inner，在局部内部类中访问外部类变量和方法
         class Inner {
             int n=1;
            void show() {
                System.out.println("外部静态变量m=" + m);
                test1();
            }
        }
        //在局部内部类的方法中，调用局部内部类变量和方法
        Inner inner=new Inner();
        System.out.println("局部内部类变量n="+inner.n);
         inner.show();
    }
    public  static void main    (String [] args){
        Animal inner=new Animal();
        inner.test2();

    }
}

匿名类（没有名字的类）

如果改方法的参数数一个类型，通常使用匿名类。
匿名内部类创建语法

interface dog{
    void shout();
}

public class Animal{
   public static void main(String [] args){
       String name="xiaohua";
       animalShout ( new dog(){
           //实现shout()方法
           public void  shout(){
               System.out.println(name+"汪汪");
           }
       });
   }
   public static void animalShout(dog an){
       an.shout();
   }
}