JAVA入门学习三

* 创建对象并使用格式：
* 类名 对象名 = new 类名();
  
* 对象名.变量名       //使用成员变量
* 对象名.方法名()     //使用成员方法

this关键字特点：
* 代表当前对象的引用 

this的应用场景:
- 用来区分成员变量和局部变量重名问题
- 可以区分多个对象

//类声明实例化调用案例
//测试类：Demo_Class
//基本类：Students
class Demo_Class {
    public static void main(String[] args) {
        //类的实例化=>对象
        Students stu = new Students();
        stu.age = 13;         //调用属性并且赋值
        stu.name = "Weiyigeek";
        stu.sex = '女';
        stu.study();         //调用方法
        stu.sleep("Weiyi",1024);         //调用方法

        //########## 执行结果 #############
        // 姓名：Weiyigeek ,年龄：13 ,性别：女 动作：正在学习
        // 姓名：Weiyi ,年龄：1024 ,性别：女 动作：正在睡觉
    }
}
/**
 * 学生类：Students
 */
 class Students {
    //属性
    String name;  //姓名
    char sex;  //性别
    int age;  //年龄

    //方法
    public void study()
    {
        System.out.println("姓名："+name+" ,年龄："+age+" ,性别："+sex+"动作：正在学习");

    }
    public void sleep(String name,int age)
    {
        this.name = name;  //局部于成员变量重名,所以前面使用 this.name 代表类中的name成员变量
        this.age = age;
        System.out.println("姓名："+name+" ,年龄："+age+" ,性别："+this.sex+"动作：正在睡觉");
    }
}

// 对象内存分析案例
class Demo_Classmemory {
    public static void main(String[] args) {
        //3个引用两个内存图
        Car c1 = new Car();  //实例化对象c1
        c1.color = "red";
        c1.run();  //red
        c1 = null; //将c1对象设置为空指针(使之不指向原来的地址)

        Car c2 = new Car(); //实例化对象c1
        c2.color = "Black";
        c2.run(); //Black
      
        Car c3 = c2; //将c3对象指向c2的地址指针，如果c2 = null; c3.run()将会出空指针异常
        c3.run(); //Black
    }   
}

class Car {
    String color;
    public void run() {
        System.out.println(color);
    }
}

class Person {
    String name; //成员变量在堆内存中，默认是null
    int num;    //同上,默认是0

    public void speak(int value)
    {
        //value 与 num 都是局部变量,在栈得上面;
        int num = 10;   // 堆里的num 与 栈里面的num 是互不影响的
        System.out.println(name);  //输出的是null
        System.out.println(num);  //在方法使用中采用的是就近原则(所以输出 10)
    }
}

//引用数据类型与基本数据类型调用的区别
class Demo_ClassQuote {
    public static void main(String[] args) {
        print(10); //调用局部方法（即基本数据类型当作形式参数）

        Student s = new Student(); //创建对象并将对象地址赋值给s
        print(s); //这里使用了方法的重载
    }

    //1.传入基本数据类型作为形式参数(传入的是值)
    public static void print(int x) 
    {
        System.out.println(x);
    }
    //2.传入引用数据类型作为形式参数 （给的是地址值）
    public static void print(Student stu)
    {
        stu.name = "WeiyiGeek";
        stu.speak();
    }
}
/** 
 * 创建一个学生类
*/
class Student {
    String name;
    public void speak() {
        System.out.println(name+"正在台上讲话!");
    }
}

// 10
// WeiyiGeek正在台上讲话!

// 匿名对象案例
class Demo2_Car {
    public static void main(String[] args) {
        //1.对比有名字对象与匿名对象的区别
        /*Car c1 = new Car();			//创建有名字的对象
        c1.run();
        c1.run();

        new Car().run();			//匿名对象调用方法
        new Car().run();	*/		//匿名对象只适合对方法的一次调用,因为调用多次就会产生多个对象,不如用有名字的对象	


        //2.查看下面匿名对象的内存图
        new Car().color = "red";
        new Car().num = 8;
        new Car().run();


        //3.匿名对象可以作为参数传递
        method(new Car());  //创建匿名对象，并将该对象的地址传递个method中Car c对象
        method(new Car());
    }   

/** 抽取方法提高代码的复用性 */
    public static void method(Car c)
    {
        c.color = "red";
        c.num = 1024;
        c.run();
    }
}

class Car {
    String color;			//颜色
    int num;				//轮胎数
    public void run() {
        System.out.println(color + ".|." + num);
    }
}

//############# 执行结果 ##########
// null.|.0
// red.|.1024
// red.|.1024

// 对象封装与private关键字
class Demo_Encapsulation {
    public static void main(String[] args) {
        //实例化
        Encaps en = new Encaps();
        en.name = "WeiyiGEEK";
        en.setID(500102123);  //设置私有属性
        System.out.println("用户ID值："+en.getID()); //获取私有属性
        en.getInfo();
    }
}

class Encaps {
    String name;   //公共成员变量
    private long ID;  //私有成员变量

    //获取私有的成员变量
    public long getID() {
        return ID;
    }
    //设置私有的成员变量
    public void setID(long value)
    {
        ID = value;
    }
    //公共方法
    public void getInfo()
    {
        System.out.println(name + " ： " + ID);
    }
}   

// 用户ID值：500102123
// WeiyiGEEK ： 500102123

//java对象构造方法 案例
class Demo_Contructor {
    public static void main(String[] args) {
        //案例1.构造方法的调用与使用 （有参构造）
        Base b = new Base("Weiyigeek"); //再创建对象时候系统自动帮我调用了Base类的构造方法Base()
        System.out.println("Name:"+b.getName()+"n");

        //案例2. 构造方法的重载 (无参构造)
        Base b1 = new Base();
        System.out.println("Name:"+b1.getName());

        //案例3.
        Base b2 = new Base("Hacker");  //该对象将会变成垃圾被回收
        b2 = new Base("New Hacker");   //这种方法看运行结果貌似是改名了,其实是将原对象变成垃圾
        System.out.println("Name:"+b2.getName());
    }
}

/**基础类：base */
class Base {
    private String name = "Other";
    //构造方法定义 （注意无返回值类型 |有参构造）
    public Base(String name){
        this.name = name;  //成员变量赋值 属性的进行初始化值
        System.out.println("b对象 - 这是Base类的构造方法：name = "+this.name);
    }
    //构造方法重载 （空参构造 | 常规建议放在有参构造前面）
    public Base()
    {
        this.name = "空参构造";
        System.out.println("b1对象 - 这是Base类的重载构造方法："+this.name);
    }

    public String getName(){
        return this.name;
    }
}

//################## 执行结果 ##################
// b对象 - 这是Base类的构造方法：name = Weiyigeek
// Name:Weiyigeek

// b1对象 - 这是Base类的重载构造方法：空参构造
// Name:空参构造

// b对象 - 这是Base类的构造方法：name = Hacker
// b对象 - 这是Base类的构造方法：name = New Hacker
// Name:New Hacker

//static关键字对象内存图
class Demo_StaticMemory {
    public static void main(String[] args) {
         //案例0：类名可以直接调用静态属性或者静态方法
         System.out.println("Person.country = "+ Person.country);

        //案例1.
        Person p1 = new Person("WeiyiGeek", "001");
        p1.country = "重庆";
        p1.Info();

        Person p2 = new Person("唯一", "002");
        p2.Info();

        //案例2：类名可以直接调用静态属性或者静态方法
        System.out.println("Person.country = "+ Person.country);
    }
}
/** Person 类 */
class Person {
    String name;  //公共成员变量
    private String id;  //私有成员变量
    static String country = "未知城镇";  //静态成员变量 (公共对象共享)

    //构造方法（有参）
    public Person(String name,String id)
    {
        System.out.println("######进入构造方法！##########");
        this.name = name;
        this.id = id;
    }
    public void Info(){
        System.out.println("个人信息:n姓名:"+this.name+"tid:"+this.id+"t城市:"+country);
    }
}

// Person.country = 未知城镇
// ######进入构造方法！##########
// 个人信息:
// 姓名:WeiyiGeek	id:001	城市:重庆
// ######进入构造方法！##########
// 个人信息:
// 姓名:唯一	id:002	城市:重庆
// Person.country = 重庆

// 静态变量/方法 非静态变量/方法
class Demo_StaticVariable {
    public static void main(String[] args) {
        //案例1.非静态成员方法
        Base1 b1 = new Base1();
        b1.print();

        //案例2.静态成员方法
        Base1.print2();
   }
}

class Base1 {
    int id = 1024;  //非静态
    static int score = 78; //静态
    
    //非静态成员方法,即可以访问静态的成员也可以访问非静态的成员
    public void print() {
        System.out.println("非静态方法："+id);
        System.out.println(score);
    }

    //静态成员方法不能访问非静态的,错误：无法从静态上下文中引用非静态
    public static void print2() {
        //System.out.println("非静态方法："+this.id); //会执行错误,由于静态方法/变量 再创建对象前都已经被创建静态区所以这里无法使用this
        System.out.println("静态方法："+score); //静态变量/方法 同时创建所以可以利用score进行调用
    }
}

// 非静态方法：1024
// 78
// 静态方法：78

//ArrayTools.class
/**
 * 数组工具类验证(注意生成doc文档的java类需要设置public关键字)
 * @author Weiyigeek
 * @version v1.0
 * **/
public class ArrayTools {
    //私有构造方法
    private ArrayTools() {}
    /**
     * getArrMax获取数组中最大值
     * @param arr 接收一个int类型的数据在
     * @return 返回数据在中的最大值
     ***/
    public static int getArrMax(int[] arr)
    {
       int max = arr[0];
       for(int i = 0; i < arr.length; i++)
       {
           max = max > arr[i] ? max:arr[i];
       } 
       return max;
    }
}

//Main1.class
class Main1 {
    public static void main(String[] args)
    {
        int[] arr = {10,1,8,5,2};
        ArrayTools at = ArrayTools(){};
        ArrayTools.getArrmax(arr);
    }
}

// c:UsersAdministratorDesktopStudy-PromgramJAVADay2>javadoc -d API -author -version ArrayTools.java
// 正在加载源文件ArrayTools.java...
// 正在构造 Javadoc 信息...
// 正在创建目标目录: "API"
// 标准 Doclet 版本 1.8.0_211

//代码块案例演示
class Demo_Blockcode {

    //静态代码块会随着Demo_Blockcode.class一起加载；
    static {
        System.out.println("1.主方法中的静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("2.主方法main");

        //局部代码块
        {
         int x = 1024;   //限定变量的声明周期
         System.out.println("3.主方法main中代码块"+x);
        }

        Baser b = new Baser();
    }

}

/**基础类 */
class Baser {
    // 静态代码块：随着类加载而加载,且只执行一次
    // 作用:用来给类进行初始化,一般用来加载驱动 ，静态代码块是优先于主方法执行
    static {
        System.out.println("4.Base类的静态代码块");
    }

    public Baser() {
        System.out.println("7.Base类构造方法");
    }

    //构造代码块:每创建一次对象就会执行一次,优先于构造函数执行
    {
        System.out.println("5.Base类构造代码块");
        test();
    }

    public void test() {
        System.out.println("6.Base类构造代码块调用的test()函数");
    }
}

// 1.主方法中的静态代码块
// 2.主方法main
// 3.主方法main中代码块1024
// 4.Base类的静态代码块
// 5.Base类构造代码块
// 6.Base类构造代码块调用的test()函数
// 7.Base类构造方法

//继承讲解 extends
class Demo_ClassExtends {
    public static void main(String[] args) {
        //1.多层继承，使用最底层进行实例化对象
        grandChild child = new grandChild();
        child.grandChildFun();
        child.childFun();
        child.parentFun();
    }
}

//父类
class Parent {
    int num1 = 10;
    //子类默认是不能继承父类的构造方法,需要借助后面讲解的super进行访问
    public Parent() {
        System.out.println("父类里面的构造方法！");
    }
    //父类公共方法
    public void parentFun() {
        System.out.println("我是父类里面得方法-parentFun()");
    }
    //父类私有成员此时子类是无法访问得（除非后面讲解得映射）
    private void show() {
        System.out.println("父类里的私有方法-继承的子类是无法访问的");
    }
}

//子类
class Child extends Parent {
    int num1 = 20;
    //子类公共方法
    public void childFun() {
        System.out.println("我是子类里面得方法-childFun()");
    }
}

//多层继承子类 - > 孙子类
class grandChild extends Child{
    //由于就进原则，子类又就不用父类的了
    int num1 = 30; //字父类出现同名的变量是再讲课中，实际上可以直接继承父类的num1；

     //孙子类公共方法
     public void grandChildFun() {
        System.out.println("我是孙子类里面得方法-grandChildFun(); num1 = " + num1); //num1 = 30
    }
}

// 父类里面的构造方法！
// 我是孙子类里面得方法-grandChildFun(); num1 = 30
// 我是子类里面得方法-childFun()
// 我是父类里面得方法-parentFun()

//继承中的构造方法
class Demo_ClassSuper {
    public static void main(String[] args) {
        //继承构造
        Son son = new Son();
        son.print();
        System.out.println("-------------------------");
        son = new Son(65536);
        son.print();
    }
}

//如果取消类构造方法，系统会自动添加空参构造方法
//父类 Father ，Object是最顶层的父类
class Father extends Object {
    int father = 1024;
    public Father() {
        super();  //当然这里也可加入父类有参 super(32768)
        System.out.println("父类 空参 构造方法");
    }
    public Father(int value) {
        this.father = value;
        System.out.println("父类 有参 构造方法");
    }
}

//子类
class Son extends Father {
    int father = 2048;

    //子类空参
    public Son() {
        //super();    //缺省该super()是系统自动添加的 ， 必须放在构造器的第一条语句,在构造中与super()不能同时存在
        this(10000);   //本类中的构造方法 ， 必须放在构造器的第一条语句,在构造中与super()不能同时存在
        System.out.println("子类 空参 构造方法"); //再父子类执行后执行
    }
    //子类有参
    public Son(int value) {
        super(value);
        System.out.println("子类 有参 构造方法");
    }

    public void print() {
        System.out.println("父类："+super.father);
        System.out.println("子类："+this.father);  //this既可以输出本类变量也可以输出父类的变量(前提是本类没有父类的重名变量)
        System.out.println("子类："+father);
    }
}

// 父类 有参 构造方法
// 子类 有参 构造方法
// 子类 空参 构造方法
// 父类：10000
// 子类：2048
// 子类：2048
// -------------------------
// 父类 有参 构造方法
// 子类 有参 构造方法
// 父类：65536
// 子类：2048
// 子类：2048

// 继承中方法的重写
class Demo_ClassOverwrite {
    public static void main(String[] args) {
        //注意：子类重写父类方法的时候最好声明一模一样
        IOS8 ios = new IOS8();
        ios.call();
        ios.siriSpeak();
        IOS7.print();
    }
}

//父类IOS7
class IOS7 {
    //公共方法
    public void call() {
        System.out.println("使用 Phone 打电话!");
    }
    //私有方法
    private void play() {
        System.out.println("使用 Phone 打玩游戏! - 私有方法不能被重写!");
    }
    //需要重写的父类方法
    public void siriSpeak() {
        System.out.println("Speak English!");
        this.play();  //调用私有方法

    }
    //静态方法只能覆盖静态其实不算重写,多态的时候详细讲解
    public static void print() {
        System.out.println("使用 Phone 打印文章! -静态方法只能覆盖静态其实不算重写,多态的时候详细讲解");
    }
}

//子类IOS8
class IOS8 extends IOS7 {
    //子类方法与父类方法定义一致（或注意定义关键字一般是一致的）
    public void siriSpeak() {
        System.out.println("Speak Chinese!中文");
        super.siriSpeak();  //除了构造方法有规则父类需要写入到第一句，其他方法没有这个讲究；
    }
}

// 使用 Phone 打电话!
// Speak Chinese!中文
// Speak English!
// 使用 Phone 打玩游戏! - 私有方法不能被重写!
// 使用 Phone 打印文章! -静态方法只能覆盖静态其实不算重写,多态的时候详细讲解

//使用继承学生与老师案例
class Demo_Demo2 {
    public static void main(String[] args) {
        //1.实例
        Teacher tea = new Teacher("Weiyi",25);
        tea.eat();
        tea.action();
        System.out.println("------------------------");
        Studentss stu = new Studentss("Geek", 18);
        stu.eat();
        stu.action();
    }
}

//学生与老师共有类
class Pub {
    String name;
    int age;

    //父类构造方法
    public Pub(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Pub 类得有参构造方法");
    }

    //公共方法
    public void eat() {
        System.out.println("共有类吃饭方法");
    }
    //override 重写方法
    public void action() {
        System.out.println("将要被子类重写方法");
    }
}

//老师继承Pub
class Teacher extends Pub {
    public Teacher(String name,int age)
    {
        super(name,age);
        System.out.println("Teacher 类得有参构造方法");
    }

    //重写父类中行为方法
    public void action() {
        System.out.println(this.name+" 【正在讲课！】");
    }
}

//学生继承Pub
class Studentss extends Pub {
    public Studentss(String name, int age) {
        super(name,age);
        System.out.println("Student 类得有参构造方法");
    }

    //override 行为方法
    public void action() {
        System.out.println(this.name+"【正在学习！】");
    }
}

//########### 执行结果 ###############
// Pub 类得有参构造方法
// Teacher 类得有参构造方法
// 共有类吃饭方法
// Weiyi 【正在讲课！】
// ------------------------
// Pub 类得有参构造方法
// Student 类得有参构造方法
// 共有类吃饭方法
// Geek【正在学习！】

//final 关键字讲解
class Demo_Final {
    public static void main(String[] args) {
        //案例1.final 定义过得基本类型是不能被改变得
        DemoFinal fi = new DemoFinal();

        //案例2：地址值不能被改变,对象中得属性可以改变
        final Dm1 o = new Dm1("Whoami"); 
        o.getName();
        o.setName("Weiyigeek");
        o.getName();
    }
}

// ########### 执行结果 ##########
// 1024 , 1
// Whoami
// Weiyigeek


//类1：
class DemoFinal {
    //final 常常 public static 与连用
    public static final int NUM = 1024; //方法1：被final修饰得成员变量只能初始化一次 (且值不能被改变值 就是常量)
    final int COUNT;      //方法2：注意成员变量得默认初始化值是无效得
    public DemoFinal() {  //再对象构造方法中进行设置
       COUNT = 1;
        System.out.println(this.NUM + " , " + this.COUNT);
    }
}

//类2:类不能被继承
final class Dm1 {
    private String name;
    public Dm1(String value) {
        this.name = value;
    }
    public void getName() {
        System.out.println(this.name);
    }
    public void setName(String value) {
        this.name = value;
    }

    //被final修饰得方法不能被重写
    public final void notOverride() {
        System.out.println("这是不能被重写得类方法");
    }
}

/***
 * 多态体现案例：
 */
class Demo1_Polymorphic {
    public static void main(String[] args)
    {
        //示例1.Cat类实例化
        Cat c = new Cat();
        c.eat();

        //示例2.父类引用指向子类对象
        Animal a = new Cat(); //代表了是动物里面的猫
        a.eat();


        //示例3.多态的伪装
        Animal wz = new Cat(); //它是动物但它实际是猫 使用动物类结构来声明 new cat 类
        System.out.println("" + wz.name); //这里显示它的大类，实际名称是猫
        wz.action(); //实际是猫在做的事情
        //如果下面调用wz.play就会报错由于父类中没有定义该play的成员方法
        //wz.play();  //如果要正确执行就需要后面遇到的 [ 向上转型和向下转型 方法]
    }
}

class Animal {
    String  name = "大类-猫科";
    public void eat() {
        System.out.println("动物正在吃饭!");
    }
    public void action() {
        System.out.println("动物正在做自己该做的事情!");
    }
}

class Cat extends Animal {
    String name = "小类-猫儿";
    public void eat(){
        System.out.println("猫儿吃鱼!");
    }
    public void action(){
        System.out.println("猫儿正在勤劳的抓老鼠！");
    }
    public void play(){
        System.out.println("猫儿玩耍中.....");
    }
}

//###输出结果####//
猫儿吃鱼!
猫儿吃鱼!
大类-猫科
猫儿正在勤劳的抓老鼠！

/***
 * 多态Polymorphic中的特点
 * 成员变量 与 成员方法 与 静态方法
 ***/
class Demo1_polymorphic1 {
    public static void main(String[] args)
    {
        //示例1.特点之成员变量
        Father f = new Son();      //注意看左边父类
        System.out.println("father 类定义" + f.num);

        Son s = new Son();
        System.out.println("son 类定义：" + s.num);

        //示例2.特点之成员方法
        f.print();  //实际还是指向子类的方法
        s.print();

        //示例3.特点之静态方法
        f.printf();  //相当于是Father.printf() 即类名直接调用
        s.printf();
    }
}

//父类
class Father {
    int num = 10;
    public void print(){
        System.out.println("我是一个父类");
    }
    public static void printf() {
        System.out.println("我是一个Father父类的静态方法");
    }
}
//子类
class Son extends Father {
    int num = 20;
    public void print(){
        System.out.println("我是一个子类");
    }
    public static void printf() {
        System.out.println("我是一个Son子类的静态方法");
    }
}

//###输出结果####//
father 类定义10
son 类定义：20
我是一个子类
我是一个子类
我是一个Father父类的静态方法
我是一个Son子类的静态方法

/**
 * 演示：多态中向上转型和向下转型
 *  */
class Demo1_polymorphicSuperman {
    public static void main(String[] args) {
        //##示例1.##
        Person p = new Superman();   //这是向上转型 （重点）
        System.out.println(p.name);
        p.测试(); //编译看左边(父类方法),运行看右边(子类方法)
        Superman su = (Superman)p;  //这是向下转型 （就可以使用子类的静态方法和成员变量）
        System.out.println(su.name);
        su.测试(); //执行子类方法
        su.fly();  //执行子类方法


        //##示例2.###
        //Animal a = new Cat(); //开发的是很少在创建对象的时候用父类引用指向子类对象,直接创建子类对象更方便,可以使用子类中的特有属性和行为
        method(new Cat());
        method(new Dog());
    }

    //如果把狗强转成猫就会出现类型转换异常,ClassCastException
    public static void method(Animal a) {	//采用父类当作当作参数的时候用多态最好,因为扩展性强
    //上下都是关键点（重点值得学习）
    if (a instanceof Cat) {
      Cat c = (Cat)a;  //强制转换（多态的向下转换）
      c.eat();
      c.catchMouse();
    }else if (a instanceof Dog) {
      Dog d = (Dog)a;
      d.eat();
      d.lookHome();
    }else {
     a.eat();
     }
  }
}

class Person {
    String name = "Person";
    public void 测试() { System.out.println("person人类测试！");}
}
class Superman extends Person {
    String name = "Superman";
    public void 测试() { System.out.println("Superman超人测试！");}
    public void fly() { System.out.println("去救人！");}
}

class Animal {
    public void eat() {System.out.println("动物吃饭");}
}
class Cat extends Animal {
  public void eat() {System.out.println("猫吃鱼");}
  public void catchMouse() {System.out.println("抓老鼠");}
}
class Dog extends Animal {
  public void eat() {System.out.println("狗吃肉");}
  public void lookHome() {System.out.println("看家");}
}

//#########执行结果###############//
// Person
// Superman超人测试！
// Superman
// Superman超人测试！
// 去救人！

// 猫吃鱼
// 抓老鼠
// 狗吃肉
// 看家

class abstractDemo {
    public static void main(String[] args)
    {
    //1.Animal是抽象的不能进行实例化,所有会报错;
       //Animal a = new Animal(); //Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    //2.但是可以通过多态来,将 父类引用指向子类对象 
        Animal c = new Cat();
        c.eat();
    //3.抽象类的特点
        c.print();

// 执行结果
// 【多态重写】Cat eat Fishc!
// 【抽象类中可以有 非抽象成员方法 】
    }
}

abstract class Animal {    //抽象类
    int num1 = 10;         //抽象类中成员变量可以是变量也可以是常量
    final int num2 = 20;    //为了给子类初始化
    public void demo(){};
    public void print(){
        System.out.println("【抽象类中可以有 非抽象成员方法 】");
    }
    public abstract void eat();  //抽象方法
}
//多态重写抽象类里的抽象方法
class Cat extends Animal {
    public void eat(){
        System.out.println("【多态重写】Cat eat Fishc!");
    }
}

abstract class CCat extends Animal {
    public void eat1 () {  
        System.out.println("【抽象类子类】 mutil Cat eat Fishc!");
    }
}

public class abstractDemo1 {
    // 抽象类进行练习
// * 具体事物：猫，狗
// * 共性：姓名，年龄，吃饭
// * 猫的特性:抓老鼠
// * 狗的特性:看家
    public static void main(String[] args) {
        Cat c = new Cat("1", 8);
        Dog d = new Dog("1", 12);
        System.out.println("Cat 姓名："+ c.getName() +" 年龄："+c.getAge());
        c.eat();
        c.ability();

        System.out.println("Dog 姓名："+ d.getName() +" 年龄："+d.getAge());
        d.eat();
        d.ability();
    }
}

//定义一个抽象类
abstract class Animal {
    private String name;
    private int age;
    public Animal(){};      //空参构造函数
    public Animal(String name,int age){      //有参构造函数
        this.name = name;
        this.age = age;
    }

    //设置姓名
    public void setName(String name){
        this.name = name;
    }
    //获取姓名
    public String getName(){
        return name;
    }
    //设置年龄
    public void setAge(int age) {
        this.age = age;
    }
    //获取年龄
    public int getAge() {
        return age;
    }
    public abstract void eat();
}


class Cat extends Animal {
    public Cat() {}; //空参
    public Cat(String name, int age) {
        super(name, age); //由于是私有成员变量,需要将更改传入super父类那里;
    }
    public void eat(){
        System.out.println("Cat eat Fishc!!");
    }
    public void ability(){
        System.out.println("Catch MOUSE!");
    }
}

class Dog extends Animal {
    public Dog(){}; //空参
    public Dog(String name, int age) { //有参
        //由于是私有成员变量,需要将更改传入super父类那里;
        super(name,age);
    }
    public void eat(){
        System.out.println("Cat eat Bone!!");
    }
    public void ability(){
        System.out.println("Catch House!");
    }
}

Cat 姓名：1 年龄：8
Cat eat Fishc!!
Catch MOUSE!
Dog 姓名：1 年龄：12
Cat eat Bone!!
Catch House!

Process finished with exit code 0

/**
 * # @File : InterfaceDemo1.java
 * # @CreateTime : 2019/7/26 9:58
 * # @Author : WeiyiGeek
 * # @Function :实现Interface接口学习与利用
 **/

public class InterfaceDemo1 {
    public static void main(String[] args){
        //1.接口不能被实例化,与调用抽象方法是一致的没有任何意义
        // Inter i = new Inter()

        //2.接口采用多态的方式进行调用
        //(1) 普通类
        Inter i = new Demo();  //父类引用指向子类对象
        i.print();

        //(2) 接口子类抽象类->多态调用
        Inter j = new sub();
        j.print();

        //3.接口中的成员变量
        String num1 = String.valueOf(i.num1);
        String num2 = String.valueOf(Inter.num2);
        System.out.println(num1 + num2); //静态成员方法可以直接采用 类名.属性 进行调用
        System.out.print(i.num1+" VS "+Inter.num2); //静态成员方法可以直接采用 类名.属性 进行调用

    }
}

//接口定义
interface Inter {
    //接口中成员变量(是常量并且是静态的并公共的)，默认修饰符：public static final
    int num1 = 1024;   //效果同下
    public static final int num2 = 1024;  //推荐方式

    //接口中方法都是抽象的,不能定义非抽象方法，以及没有构造方法
    public abstract void print();
}

//接口实现 - 具体类(普通类)
class Demo implements Inter {
    //构造方法
    public Demo() {
        super();  //默认是继承Object类即：Class Demo extends Object implements Inter
    }
    //重写抽象方法
    public void print(){
        System.out.println("[1].接口子类-普通类-抽象方法被调用");
    }
}

//接口实现 - 抽象类
abstract class Demo1 implements Inter {
    public abstract void print();  //无任何意义
}
//继承实现
class sub extends Demo1 {
    public void print(){
        System.out.println("[2.]接口子类-抽象类-多态方式-抽象方法被调用");
    }
}

[1].接口子类-普通类-抽象方法被调用
[2.]接口子类-抽象类-多态方式-抽象方法被调用
10241024
1024 VS 1024

/**
 * # @File : InterfaceDemo2.java
 * # @CreateTime : 2019/7/26 10:45
 * # @Author : WeiyiGeek
 * # @Function :抽象类与接口区别案例
 **/

public class InterfaceDemo2 {
    public static void main(String[] args) {
        //继承类
        Cat1 c = new Cat1("Love",12);
        c.eat();
        c.play();

        //普通类-继承类与接口
        JumpCat d = new JumpCat("baby", 13);
        d.eat();
        d.play();
    }
}

//父类
abstract class AnimalFather {
    private String name;
    private int age;
    public AnimalFather(String name, int age) {
        this.name = name;
        this.age = age;
    }
   //建立方法方便返回私有成员变量
    public String getName() {
        return this.name;
    }

    //抽象方法
    public abstract void eat();
    public abstract void play();
}

//接口类
interface Jumping {
    public abstract void jump();
}

//继承类 - 实现重写
class Cat1 extends AnimalFather {
    public Cat1(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(super.getName() + "Cat eat Fishc！");
    }
    @Override
    public void play() {
        System.out.println(super.getName() + "Cat play 毛线");
    }
}

//类继承Cat1又继承接口
class JumpCat extends Cat1 implements Jumping {
    //需要一个有参构造 （注意不要忘记，虽然Cat1类类存在，但是任然需要）
    public JumpCat(String name, int age) {
        super(name, age);
    }
    //重写接口中抽象方法
    public void jump(){
        System.out.println("Cat Jumping！");
    }
}

LoveCat eat Fishc！
LoveCat play 毛线
babyCat eat Fishc！
babyCat play 毛线

public class Demo_Classdesign {
  public static void main(String[] args) {
    // 装饰设计模式
    // 优点:耦合性没有这么强,便于功能的扩展;（值得学习借鉴）
    Tea t = new Tea(new Stu());
    t.able();
  }
}

//接口
interface code{
  public void able();
}

//扩展接口
class Stu implements code {
  @Override
  public void able() {
    // TODO Auto-generated method stub
    System.out.println("C");
    System.out.println("C++");
    System.out.println("VF");
  }
}

//装饰设计(精华之处)
class Tea implements code {
  private Stu demo;  //获取到被包装的类的引用
  public Tea(Stu demo) { //通过构造函数创建对象的时候,传入被包装的对象
    super();
    this.demo = demo;
  }
  @Override
  public void able() {
    demo.able();  //扩展技能
    System.out.println("### 扩展的技能 ###");
    System.out.println("Python");
    System.out.println("Perl");
    System.out.println("php");
    System.out.println("Javascript");
    System.out.println("Java");
    System.out.println("Node.js");
    System.out.println("HTML/XML");
  }
}
//###### 执行结果 #######
// C
// C++
// VF
// ### 扩展的技能 ###
// Python
// Perl
// php
// Javascript
// Java
// Node.js
// HTML/XML

//开始在测试类中每个具体的内容自己创建对象，但是创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。
// * 动物抽象类：public abstract Animal { public abstract void eat(); }
// * 具体狗类：public class Dog extends Animal {}
// * 具体猫类：public class Cat extends Animal {}

//Animal.java 抽象类
public abstract class Animal {
  //狗类/狗类继承方法
  public abstract void eat();
}

//狗类 Dog.java
class Dog extends Animal {
  @Override
  public void eat() {
    System.out.println("狗啃骨头!");
  }
}

//猫类 Cat.java
class Cat extends Animal {
  @Override
  public void eat() {
    System.out.println("猫吃鱼儿!");
  }
}

//-------------------
//简单工厂设计模式Factory.java
public class Factory {
  //方式1:
  //public static Dog createDog() {return new Dog();}
  //public static Cat createCat() {return new Cat();}
  
  //方法2:
  public static Animal createanimal(String animalname)
	{
    if("Dog".equals(animalname)){
      return new Dog();
    }else if("Cat".equals(animalname)){
      return new Cat();
    }else {
      return null;
    }
  }
}

//---------
//注意：同一路径下的包不用导入，工厂模式测试类
public class Demo5_SimpleFactory {
  //（1）实例1.测试简单工厂方法模式
  //public static Dog createDog() {return new Dog();}
  //public static Cat createCat() {return new Cat();}
  public static void main(String[] args) {
    Factory f1 = new Factory();  //创建工厂方法模式对象
    Dog d = (Dog)f1.createanimal("Dog"); //向下转型
    d.eat();
    
    Cat c = (Cat)f1.createanimal("Cat"); //向下转型
    c.eat();
  }
}

狗啃骨头!
猫吃鱼儿!

//开始，在测试类中每个具体的内容自己创建对象，但是创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
动物抽象类：public abstract Animal { public abstract void eat(); }
具体狗类：public class Dog extends Animal {}
具体猫类：public class Cat extends Animal {}
//以上代码都不变


//工厂接口：
public interface Factory {public abstract Animal createAnimal();} //接口中的抽象方法是猫、狗的父类

//狗工厂/猫工厂（测试的时候同时写入到了一个class文件）
// public class DogFactory implements Factory {public Animal createAnimal() {}}
// public class CatFactory implements Factory {public Animal createAnimal() {}} 
//狗类 DogFactor.java
class DogFactory  implements Factory1 {
  @Override
  public Animal createAnimal() {
    return new Dog();
  }
}

//猫类 CatFactor.java
class CatFactory implements Factory1  {
  @Override
  public Animal createAnimal() {
    return new Cat();
  }
}

//-----工厂方法设计模式-----
//注意：同一路径下的包不用导入
public class Demo5_Factory {
  //实例1.测试工厂方法模式
  public static void main(String[] args) {
        //实现狗/猫工厂设计模式（非常值得学习）
    DogFactory df = new DogFactory();
    Dog d = (Dog)df.createAnimal();
    d.eat();
    
    CatFactory cf = new CatFactory();
    Cat c = (Cat)cf.createAnimal();
    c.eat();
  }
}
//执行结果同上(比较推荐此方式)