类与对象。

类：
类是描述一个事物（对象）的集合，涵盖了事物的属性特征和行为特征。
属性特征：描述事物的状态。（是什么）
行为特征：描述事物的行为。（能做什么）
对象：
是类的具体，是类的一个具体实例。人类====男人 + 女人。
关系：类是抽象的，对象是具体的。

//对象的创建与访问
//数据类型：8种数据类型，引用数据类型
//格式：数据类型		变量名称 = new	数据类型（）；
变量名称放入栈中，new开辟的空间放入堆中，当栈中地址与堆中地址一致时就可以访问，所以叫访问数据类型，
定义类就是定义类的成员，包括成员变量和成员方法。
定义成员变量：和以前定义变量时一样的，定义在类中方法外
定义成员方法：把static去掉

package method;

public class ClassDemo
{
    public static void main(String[] args)
    {
        Emp emp = new Emp();//这里的Emp一定要是对象所在类的类名
        emp.name = "张三";
        emp.age = 19;
        emp.salary = 22000.2;
        emp.empno = 12;
        emp.println(emp);
        emp.eat(emp);
    }
}

package method;

public class Emp
{
    String name;
    int age;
    double salary;
    int empno;

    public void eat(Emp emp)//对象引用
        {
            System.out.println(emp.name+"开始吃饭了");
        }
    public void println(Emp emp)
    {
        System.out.println(emp.empno+"号员工今年"+emp.age+"岁，他是学java的，他的薪资是："+emp.salary+"他叫："+emp.name);
    }
}

（1）首先在主函数里面声明一个对象：如Emp emp = new emp();
其次另外创建一个类用于存放该对象，对该对象的具体属性进行声明，当中若有方法则不加static(主函数要调用)，Emp emp就是一个对象的声明，只不过未开辟空间。
（2）在主函数里面调用放入参数emp对象即可
注意：以上都是在同一个包里访问的对象。
（3）直接打印对象名，打印出来的是对象的地址。
（4）栈：先进后出，用完就退栈

用new开辟的空间存到堆里面，并赋初值，存放对象（并且拿出对象成员赋初值）。
方法区存放类的信息（成员变量、成员方法），只存变量名，方法名。
栈中存放方法的具体内容，当运行到该方法时，在栈中开辟空间（栈帧）。

//对象作为函数的返回值
package method;

public class Stu
{
    public static void main(String[] args)
    {
       student S = method();
        System.out.println(S.name);
        System.out.println(S.score);
        System.out.println(S.StuNo);
        S.eat(S);
    }
    public static student method()
    {
        student S1 = new student();
        S1.name = "张三";
        S1.score = 78;
        S1.StuNo = 180527;
        return S1;
    }
}

package method;

public class student
{

    String name;
    int StuNo;
    int score;
    public void eat(student Stu)
    {
        System.out.println(Stu.name+"要开始吃饭了");
    }
    public static void main(String[] args)
    {
        student Stu = new student();
    }
}

对象要作为一个新的实例化的类，要依据类来创建对象，类是对象的模板，对象是类的实例。在方法外声明成员，方法内声明变量，对象的函数成员不加static关键字。

方法区：
存储.class的相关内容；
成员变量、成员方法，其中成员方法是有存储地址值的。
栈：【特点是先进后出，main()方法是最先进入的，最后出去的】
存储的如果是基本数据，存的直接是值。
存储的如果是引用数据，存储的是地址值
堆：（new出来的）
存放的是对象值
成员方法在对象中，所以成员方法存在堆中
//垃圾回收机制
gc()
是系统基本线程
gc对程序员来讲是透明的，我们可以通过建议的方式来实现垃圾回收，System.gc()
什么是垃圾：
没有引用所指向的对象，就会被是为垃圾
Cell cell = new Cell();
cell = NULL;
此时堆中所存储的对象就被视为一个垃圾。
当不可用的对象在堆中存储过多就被造成内存泄漏。

package的声明是有层次的，一般分为四个部分。
第一部分：公司或组织域名反写
第二部分:项目名称
第三部分：组织名称
第四部分：类名称
类的修饰只有两种，public和不加public,设置private是完全没有意义的；
private:表示私有的，不公开的，只能在类内使用。

package Demo;

public class Pri
{
    public static void main(String[] args)
    {
        DuiX Age = new DuiX();
        Age.setage(60);
        int age = Age.getage();
        System.out.println(age);
    }
}

package Demo;

public class DuiX
{
    private int age;//只能该类访问
    public void setage(int num)
    {
        if(num<0||num>=120)
        {
            System.out.println("年龄非法");
        }
        else
        {
            age = num;
        }
    }
    public  int getage()//对象里面方法不加static
    {
        return age;
    }
}

this:简单来讲就是当前类的对象，常放在对象类中打点访问。
//如这块age属于局部变量，

public void setage(int age)
    {
        if(age<0||age>=120)
        {
            System.out.println("年龄非法");
        }
        else
        {
            this.age = age;
        }
    }

构造方法的特点：
构造方法是专门用于创建对象的方法，其特点有二
1.方法没有返回值类型：2.方法的名称和当前类名称相同
注意：
1.构造方法是可以发生重载的！[重载：发生在同 方法 参数列表不同（顺序不同，个数不同，类型不同）]
2.如果没有撰写任何的构造方法，jdk会帮我们自动到一个的遇只显示的添加了一个构造方法，默认的无参构造失效。
3.构造方法不能return一个具体的返回值。
4.构造方法不能有返回值类型，连Void都不能写
5.构造方法的名称一定要和类名相同

public class Student (
String name;
int age;
//没有构造方法，jdk会默认提供一不示
//如果自定义了一个有参构造，则默认的无参方法将被覆盖：public Student()不存在
//那么，如果还要是用无参数的对象一就需要手动添圳一个无参构造方法
public Student(int a){}
//创建对象

//主函数

//构造方法的应用，对接于对象，（）里面可以有也可以无参数。
这里可以定义两个不同的对象，参数也不同，但是模板一样且都放在方法前面（名字，年龄），两个对象两个空间（参数列表不同），存放不同的内容。

//extends是继承关键词，子类可继承父类的公共方法和属性，对于private是不可继承的。
class demo1
{
    public int age;
    private int num;
}
class son extends demo1
{
    
}

父类子类的应用

package Demo;

public class Fu
{
    public int a = 999;
    private int b = 66;
    public void GetB()
    {
        System.out.println(b);
    }
}
============================
package Demo;

public class Zi extends Fu
{
    private int b = 88;

    public void method()
    {
        System.out.println(this.b);//哪个对象调用了这个方法，this就是哪个对象,this必须要在方法中体现（对象的引用）
        System.out.println(super.a);//调用对象的类如果是子类，那输出他的父类的值，super要在子类的方法中体现
    }
}
============================
package Demo;

public class Test
{
    public static void main(String[] args)
    {
        int b = 22;
        Fu demo1 = new Fu();
        Zi demo2 = new Zi();
        System.out.println(b);
        demo2.method();
    }
}

总结：
子类=自己的成员变量+父类的非私有成员变量，自己的成员方法+父类的非私有成员方法。
变量如果重名，子类既可以访问自己的变量，也可以访问父类的变量。
方法如果重名，子类可以访问自己的，也可以通过创建一个方法，把方法存到另一个方法里，完成访问。
父类=自己的成员变量+成员方法。

生活中的继承：
动物 s = new 食肉动物（）；
因此：Fu A = new Zi();
假如一个方法在父类子类中都有，调用时，优先查找父类，发现父类里面有但是子类进行了方法的重写；假如有个get方法，Zi有，Fu没有,A.是访问不到get方法的，因为父类不能查找子类的方法，子类能继承父类的方法。
重载与重写的区别：重写发生在父子类中，方法名相同，参数列表相同；
重载发生在一个类中，方法名相同，参数列表一定不同。
！！！方法的重写与重载

package Demo;

public class loadandover
{
    public static void main(String[] args)
    {
        supe obj /*大类型*/= new sub();/* 小类型 */
        obj.g();//方法的重写，是sub类，
                //发生在有关系的父子类中
                //
        goo agg = new goo();
        agg.g(new sub());//方法重载，紧邻supe,所以是supe类的
        agg.g(obj);//可以传大类型，也可以传小类型
    }
}
//方法的重写发生在两个类中
//方法重写发生在一个类中（参数列表不太、方法名不同）
class supe
{
    public void g()
        {
            System.out.println("super.g");
        }
}
class sub extends supe
{
    public void g()
    {
        System.out.println("sub.g");
    }
}
class goo
{
    public void g(supe agg)//此处的参数类型必须是之前定义好的supr父类，不能是super类
    {
        System.out.println("supe(g)");
    }
    public void g(sub agg)//定义子类agg
    {
        System.out.println("sub(g)");
    }
}

package Demo;

public class fuandzi
{
    public static void main(String[] args)
    {
        zi dad = new zi();//创建对象时，zi()就先运行一次
    }
}
class fu
{
    public fu()//与上一段程序对比，名字与父类一样不加void,否则加void,可以说是父子类方法命名的两种规范
    {
        System.out.println("父类开始运行");
    }
}
class zi extends fu
{
    public zi()//
    {
        super();//super调用的构造方法必须在子类构造方法第一行，必须放在子类中
        System.out.println("子类开始运行");
    }
}

super的三种使用方法：
1、在子类成员方法中，使用父类成员方法
2、在子类成员方法中，使用父类成员变量
3、在构造方法中（即方法名是类名，不加void）,直接调用super,便是让父类再运行一次

this三种用法
1、在本类成员方法中，访问本类的成员变量
2、在本类的成员方法中，访问本类其他的成员方法
3、本类的构造方法中，访问本类其他构造方法（多个构造方法避免出现死循环现象）
注意：
super是用来访问父类的内容
this关键字是用来访问本类的内容

package Demo;

public class thiskey
{
    public static void main(String[] args)
    {
        fu1 fu2 = new fu1();
        zi1 zi2 = new zi1();
    }
}
class fu1
{
    int num = 10;
    public void method1()
    {
        System.out.println(this.num);//访问本类成员变量
        System.out.println("this is fu");
        this.method2();//访问本类其他方法
    }
    public void method2()
    {
        System.out.println("this is method2");
    }
}
class zi1 extends fu1
{
    public zi1()
    {
        this(2);//必须出现在第一行
        System.out.println("zi1 null");
    }
    public zi1(int num)
    {
        System.out.println(num);
    }
}

继承特性：

抽象：所谓的抽象就是含糊的，不完全的，不清楚的。
对于父类的抽象方法，子类需要重写，重写就可以使抽象方法具体化
含有抽象方法的类就是抽象类
声明抽象类和抽象方法时加abstract关键字。

package Animal;

public class abstractanimal
{
    public static void main(String[] args)
    {
        animal animal1 = new Dog();
        animal1.eat();
        animal1.sleep();
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}


package Animal;

public abstract class animal
{
    public abstract void eat();
    public abstract void sleep();
}

package Animal;

public  class Dog extends animal
{
    public void eat()
    {
        System.out.println("猪吃饭");
    }
    public void sleep()
    {
        System.out.println("猪睡觉");
    }
}

注意：
1、抽象类不能实例化的，不能建对象
2、抽象类必须具有一个子类进行继承
3、子类继承了抽象类之后，一定要实现抽象类所有抽象方法，如果不实现，子类必须也是抽象类
4、抽象类是有构造方法的
5、抽象类不一定包含抽象方法，包含抽象方法的类一定是抽象类