***抽象类：abstract
当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。，分析事物不确定时，就抽象
特点
1.抽象方法只能定义在抽象类中。
2.抽象方法和抽象类必须被abstract修饰
3.抽象类不可以用new 创建对象，因为创建对象没有意义
4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。

抽象类和一般类没有太大的区别，当事物出现不确定的功能，需要明确指出，但是无法定义主体，通过抽象方法来表示。

抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象。

抽象类可以包含 普通方法 成员变量 构造方法

/*
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。

程序员：
        属性：姓名，工号，薪水。
        行为：工作内容。

项目经理：
        属性：姓名，工号，薪水，奖金。
        行为：工作内容。

两者不存在继承，但存在共性，所以向上抽取。
父类是：员工。
员工：抽象
        属性：姓名，工号，薪水。
        行为：工作。不具体。

*/

abstract class Employee
{
        private String name;
        private String id;
        private double pay;

        Employee(String name,String id,double pay)
        {
                this.name = name;
                this.id = id;
                this.pay = pay;
        }
        abstract void work();
}

//描述程序员
class Programmer extends Employee
{
        Programmer(String name,String id,double pay)
        {
                super(name,id,pay);
        }

        public void work()
        {
                System.out.println("code...");
        }
}
//描述经理。
class Manager extends Employee
{
        private double bonus;
        Manager(String name,String id,double pay,double bonus)
        {
                super(name,id,pay);
                this.bonus = bonus;
        }

        public void work()
        {
                System.out.println("manage...");
        }
}

模板方法模式：在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分
在使用不确定的部分。就将不确定的部分暴露出去。由该来的子类去实现。将确定的部分final修饰 ，禁止修改。
。
该类中定义的肯定是所有对象都具备的功能。



Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
*/

class Demo //extends Object
{
        private int num;
        Demo(int num)
        {
                this.num = num;
        }
       
        public boolean equals(Object obj)//Object obj = new Demo();
        {

                if(!(obj instanceof Demo))
                        return false;
                Demo d = (Demo)obj;

                return this.num == d.num;
        }
       
        /*
        public boolean compare(Demo d)
        {
                return this.num==d.num;
        }
        */
        public String toString()
        {
                return "demo:"+num;
        }


}
class ObjectDemo
{
        public static void main(String[] args)
        {
                Demo d1 = new Demo(4);
                System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。
                Demo d2 = new Demo(7);
                System.out.println(d2.toString());
        }
}

***内部类：
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
*访问特点：

内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
*内部类的位置差异：
内部类定义在成员位置上
可以被private static成员修饰符修饰。
被static修饰的内部类只能访问外部类中的静态成员。

内部类定义在局部位置上
也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。
*内部类直接访问外部类的原理：因为内部类持有了外部类的引用。外部类名.this
代码展示：
class Outer
{
        private int num = 4;

        //内部类。
        class Inner
        {
                int num = 5;
                void show()
                {
                        int num = 6;
                        System.out.println("inner show "+Outer.this.num);
                }
        }

        void method()
        {
                Inner in  = new Inner();
                in.show();
        }
}



class InnerClassDemo
{
        public static void main(String[] args)
        {
                Outer out = new Outer();
                out.method();
        }
}
*注意：当内部类中定义了静态成员，该内部类必须是static 的。
     当外部类中的静态方法访问内部类时，该内部类必须是静态的

***抽象类：abstract
当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。，分析事物不确定时，就抽象
特点
1.抽象方法只能定义在抽象类中。
2.抽象方法和抽象类必须被abstract修饰
3.抽象类不可以用new 创建对象，因为创建对象没有意义
4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。

抽象类和一般类没有太大的区别，当事物出现不确定的功能，需要明确指出，但是无法定义主体，通过抽象方法来表示。

抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象。

抽象类可以包含 普通方法 成员变量 构造方法

/*
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。

程序员：
        属性：姓名，工号，薪水。
        行为：工作内容。

项目经理：
        属性：姓名，工号，薪水，奖金。
        行为：工作内容。

两者不存在继承，但存在共性，所以向上抽取。
父类是：员工。
员工：抽象
        属性：姓名，工号，薪水。
        行为：工作。不具体。

*/

abstract class Employee
{
        private String name;
        private String id;
        private double pay;

        Employee(String name,String id,double pay)
        {
                this.name = name;
                this.id = id;
                this.pay = pay;
        }
        abstract void work();
}

//描述程序员
class Programmer extends Employee
{
        Programmer(String name,String id,double pay)
        {
                super(name,id,pay);
        }

        public void work()
        {
                System.out.println("code...");
        }
}
//描述经理。
class Manager extends Employee
{
        private double bonus;
        Manager(String name,String id,double pay,double bonus)
        {
                super(name,id,pay);
                this.bonus = bonus;
        }

        public void work()
        {
                System.out.println("manage...");
        }
}

模板方法模式：在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分
在使用不确定的部分。就将不确定的部分暴露出去。由该来的子类去实现。将确定的部分final修饰 ，禁止修改。
。
该类中定义的肯定是所有对象都具备的功能。



Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
*/

class Demo //extends Object
{
        private int num;
        Demo(int num)
        {
                this.num = num;
        }
       
        public boolean equals(Object obj)//Object obj = new Demo();
        {

                if(!(obj instanceof Demo))
                        return false;
                Demo d = (Demo)obj;

                return this.num == d.num;
        }
       
        /*
        public boolean compare(Demo d)
        {
                return this.num==d.num;
        }
        */
        public String toString()
        {
                return "demo:"+num;
        }


}
class ObjectDemo
{
        public static void main(String[] args)
        {
                Demo d1 = new Demo(4);
                System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。
                Demo d2 = new Demo(7);
                System.out.println(d2.toString());
        }
}

***内部类：
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
*访问特点：

内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
*内部类的位置差异：
内部类定义在成员位置上
可以被private static成员修饰符修饰。
被static修饰的内部类只能访问外部类中的静态成员。

内部类定义在局部位置上
也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。
*内部类直接访问外部类的原理：因为内部类持有了外部类的引用。外部类名.this
代码展示：
class Outer
{
        private int num = 4;

        //内部类。
        class Inner
        {
                int num = 5;
                void show()
                {
                        int num = 6;
                        System.out.println("inner show "+Outer.this.num);
                }
        }

        void method()
        {
                Inner in  = new Inner();
                in.show();
        }
}



class InnerClassDemo
{
        public static void main(String[] args)
        {
                Outer out = new Outer();
                out.method();
        }
}
*注意：当内部类中定义了静态成员，该内部类必须是static 的。
     当外部类中的静态方法访问内部类时，该内部类必须是静态的