初阶java21_类和对象认识

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/**
 * 类和对象
 *
 * 面试问题;OOP语言（面向对象编程）的三大特征：封装性、继承性、多态性。
 *
 * 1、封装性：封装是指将一个计算机系统中的数据以及与这个数据相关的一切操作语言组装到一起，
 *          一并封装在一个有机的实体中，把它们封装在一个“模块”中，也就是一个类中，为软件
 *          结构的相关部件所具有的模块性提供良好的基础。
 *
 * 2、继承性：是面向对象技术中的另外一个重要特点，其主要指的是两种或者两种以上的类之间的联
 *          系与区别。继承，顾名思义，是后者延续前者的某些方面的特点，而在面向对象技术则是
 *          指一个对象针对于另一个对象的某些独有的特点、能力进行复制或者延续。
 *
 * 3、多态性：从宏观的角度来讲，多态性是指在面向对象技术中，当不同的多个对象同时接收到同一
 *            个完全相同的消息之后，所表现出来的动作是各不相同的，具有多种形态；
 *
 *          从微观的角度来讲，多态性是指在一组对象的一个类中，面向对象技术可以使用相同的调
 *          用方式来对相同的函数名进行调用，即便这若干个具有相同函数名的函数所表示的函数是
 *          不同的。
 *
 * 类：自定义类型
 * 对象：实体---是一类对象的统称。对象就是这一类具体化的一个实例。
 * 面向对象：思考问题的一种思考方式，是一种思想。比如：概念与实例。理论与实践。名和实等等。
 *
 *      // 创建类
 *      class <class_name>{  
 *         field;//成员属性
 *         method;//成员方法
 *      }
 *      // 实例化对象
 *     <class_name> <对象名> = new <class_name>();
 *
 *
 * 访问修饰限定符：
 * public：公有的
 * private：私有的
 * protecte：受保护的
 * 什么都不写---默认权限---访问权限
 *
 */

/**
 * 1、如何访问实例成员变量
 * 2、如何访问实例成员方法
 * 3、访问实例成员初始化问题
 */
class Person{

    /**
     * 成员变量定义在方法外边，类的里边
     * 字段 --- 成员变量 ---属性
     * 实例成员变量在对象里面 -- 对象在堆上
     *
     * 实例成员没有初始化，默认值为对应的0值
     *
     * 引用类型 默认为 null
     * 简单类型 默认为 0
     * boolean -- false
     * char -- '\u0000'  --- 空格
     * double -- 0.0
     *
     *
     * 一般不在这进行实例化成员变量的初始化
     */
    public String  name = "YMT";
    public int age = 24;
    public char ch;
    public boolean flag;


    /**
     * 没有加static 称实例成员方法
     */
    //方法 --- 成员方法 --- 行为
    public  void eat(){
        int a = 10;//局部变量必须初始化才可以使用,局部变量和变量名（引用）放在栈中
        System.out.println("eat!");
    }

    public void sleep(){
        System.out.println("sleep!");
    }

}


public class Demo_4 {
    /**
     * 实例成员方法如何调用
     * @param args
     */
    public static void main(String[] args) {
        Person per = new Person();
        per.eat();
        per.sleep();
    }



    /**
     * 如何访问对象当中的实例成员变量
     *
     * 对象的引用（变量名）.成员变量
     * @param args
     */
    public static void main2(String[] args) {

        Person per = new Person();
        /**
         * 一般实例化成员在这赋值
         */
        per.name = "Hello";
        per.age = 14;

        System.out.println(per.age);
        System.out.println(per.name);
        System.out.println(per.ch);
        System.out.println(per.flag);
    }



    /**
     * 一个类可以产生多个对象
     * 实例化一个对象  ---通过关键字new
     */
    public static void main1(String[] args) {

        Person per1 = new Person();
        Person per2 = new Person();
        Person per3 = new Person();
        Person per4 = new Person();
        Person per5 = new Person();

    }
}

/**
 * 1、如何访问静态成员变量
 * 2、如何访问静态成员方法
 * 3、访问静态成员初始化问题
 */
class Person1{
    /**
     * 静态成员变量在方法区
     *
     * 不初始化依旧默认为 对应的0值
     *
     * 静态成员变量不等于对象，存放在方法区
     */

    public static int size = 10;
    public static int size1;

    /**
     * 加static 称静态成员方法
     */
    public static void eat(){
        int a = 10;//局部变量必须初始化才可以使用
        System.out.println("eat!");
    }

    public static void sleep(){
        System.out.println("sleep!");
    }


}

public class Demo_5 {
    /**
     *
     * @param args
     */
    public static void main(String[] args) {
        // Person1 per = new Person1();
        Person1.eat();
        Person1.sleep();

    }

    public static void main1(String[] args) {
        /**
         * 如何访问静态成员变量
         *
         * 类名.静态成员变量
         */
        Person1 per = new Person1();
        System.out.println(Person1.size);
        System.out.println(Person1.size1);

        /**
         * 静态成员变量内部不能访问非静态成员变量,
         * 非静态可以访问静态成员变量
         */
        //System.out.println(Person1.name); -- error
    }
}

/**
 * 理解静态成员变量 和 实例化成员变量
 *
 * 静态成员变量 只有一份
 * 实例化成员变量  有多个对象
 *
 * 1、静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
 * 2、this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也
 * 是和当前实例相关).
 */
class Test{
    public int a;
    public static int count;
}


public class Demo_6 {
    public static void main(String[] args) {
        Test t1 = new Test();
        t1.a++;//1
        Test.count++;//1
        System.out.println(t1.a);
        System.out.println(Test.count);

        System.out.println("-----------------------");

        Test t2 = new Test();
        t2.a++;//1 -- 每new一次，成员变量都有一份
        Test.count++;// -- 静态成员变量在方法区 ，只有一份
        System.out.println(t2.a);
        System.out.println(Test.count);
    }
}

/**
 *静态成员变量 如何访问 实例成员变量
 *
 * 同一工程不能建立相同的类名 均为class Test{}
 */
class Test1{
    public  void func(){
        System.out.println("dadada");
    }
    public static void func1(){
        System.out.println("hehehe");
    }
}
public class Demo_7 {
    public static void main(String[] args) {
        /**
         * 静态方法不能直接使用非静态数据成员或调用非静态方法
         * (非静态数据成员和方法都是和实例相关的).
         */
        //func();//error
        Test1.func1();

        //静态成员变量 如何访问 实例成员变量
        Test1 test = new Test1();
        test.func();

    }
}

/**
 * 总结类与方法
 */
class Person2{
       public int age;//实例变量   存放在对象内
       public String name;//实例变量
       public String sex;//实例变量

       public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
       public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改

       public static final int COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更改



       //实例成员函数
       public void eat() { int a = 10;//局部变量
           System.out.println("eat()!");
       }


        //实例成员函数
       public void sleep() {
           System.out.println("sleep()!");
       }


       //静态成员函数
       public static void staticTest(){
           //不能访问非静态成员
           //sex = "man"; error
           System.out.println("StaticTest()");
       }
}

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

        //产生对象 实例化对象
        Person2 person = new Person2();//person为对象的引用
        System.out.println(person.age);//默认值为0
        System.out.println(person.name);//默认值为null


        //System.out.println(person.count);//会有警告!
        //正确访问方式
        System.out.println(Person2.count);
        System.out.println(Person2.COUNT);


        Person2.staticTest();

        //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
        person.eat();
        person.sleep();
    }
}

/**
 * 封装：private修饰的
 */
class Student{
    public String name;
    public int age;

    //封装 -- 只能在类中进行访问，类外不能访问
    private String name1;
    private int age1;

    public  void  test(){
        System.out.println("test!");
    }

    public void show() {
    System.out.println("我叫" + name1 + ", 今年" + age1 + "岁");
    }

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

        //静态方法中访问实例成员变量
        Student student = new Student();
        student.name = "YMT";
        student.age = 18;
        System.out.println(student.name);
        System.out.println(student.age);

        //private不能再类外访问
        //System.out.println(student.name1);
        //System.out.println(student.age1);

    }

}

/**
 * 如何提供公开接口
 */
class Student1{

    //封装 -- 只能在类中进行访问，类外不能访问
    private String MyName;
    private int age;

    //提供公开的接口  ---alt + insert +set get
    public String getMyName(){
        return MyName;
    }

    public void setMyName(String name){
        MyName = name;
    }

    //注意：结果为null
    public void setMyName1(String MyName){
        // MyName = MyName;//其实就是自己给自己赋值，并没有赋值属性，局部变量优先
        this.MyName = MyName;//this代表当前对象的引用 --即当前Student1 的MyName
    }



    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }



    public  void  test(){
        System.out.println("test!");
    }

    public void show() {
        System.out.println("我叫" + this.MyName + ", 今年" + this.age + "岁");
    }



    /**
     *  alt+insert +toString
     *
     *  重新实现了一个Object的toString方法
     *  Object是所有类的父类
     * @return
     */
    @Override //这个注解代表这个方法是重新写的
    public String toString() {
        return "Student1{" +
                "MyName='" + MyName + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Demo_10 {
    public static void main(String[] args) {
        Student1 student = new Student1();
        student.getMyName();
        student.setMyName("YMT");

        student.getAge();
        student.setAge(9);

        //打印1
        String str = student.getMyName();
        System.out.println(str);
        //打印2
        System.out.println(student.getMyName());


        int a = student.getAge();
        System.out.println(a);

        System.out.println(student.getAge());

       student.show();
       //打印3
        /**
         * public void println(Object x) {
         *         String s = String.valueOf(x);
         *         synchronized (this) {
         *             print(s);
         *             newLine();
         *         }
         *     }
         */
       System.out.println(student);//打印出来类似一个数组

    }

}

/**
 * 构造方法
 * 1、构造方法的方法名 和 类名相同
 * 2、没有返回值
 * 3、构造方法不止一个 -- 可以和重载进行理解
 *
 * 注意：1、当没有提供构造方法的时候，编译器会自动提供一个，不带有参数的构造方法
 *      2、当已经提供了构造方法，编译器就不会自动生成一个构造方法。
 *
 * 构造方法的作用：实例化一个对象（构造一个对象）。
 *
 * 一个对象的产生分为几步，如何产生？
 *  答：1、为对象分配内存
 *      2、调用合适的构造方法
 *
 *
 * 面试问题：this这个关键字代表对象，对不对，为什么？
 *  答：不对，this代表当前对象的引用，
 *     因为一个对象的产生有两步，1、为对象分配内存，2、调用合适的构造方法
 *     在第二步构造方法中已经使用了this这个关键字
 *
 * this的作用：
 * 1、this() : --调用自己的构造方法
 * 2、this.data: --调用自己当前对象的属性
 * 3、this.func(): --调用自己当前对象的方法
 *
 * 注意：只有在构造方法里面写
 *      只能调用一次
 *      只能写在第一行
 *      习惯使用this
 *
 *
 * 构造方法支持重载
 *
 * 重载：1、方法名相同
 *      2、参数列表不同
 *      3、返回值不做要求
 *      4、在同一个类中
 *
 */
class Person{
    private String name;
    private int age;
    // this的作用
    public void eat() {

        //this("abc",12);//error 只有在构造方法里面写

        //调用自己当前对象的属性
        this.name = name;
        this.age = age;
        //调用自己当前对象的方法
        this.setName("abc");
    }
    //创建一个构造方法
    public Person(){
        //调用自己的构造方法
        //注意：1、只有在构造方法里面写
        //     2、只能调用一次
        //     3、只能写在第一行
        //     4、习惯使用this

        //System.out.println("hehe");//error 只能写在第一行
        //this(12);//只能调用一次 ---调用这个，就不能调用另一个
        this("abc",12);
        System.out.println("hehe");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(int age) {
        this.age = age;
    }

    //创建toString
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    //创建get set
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Demo_1 {

    public static void main(String[] args) {
        //调用构造方法
        Person per1 = new Person();
        Person per2 = new Person("YMT",19);
        Person per3 = new Person("Ymt");
        Person per4 = new Person(20);

        per2.getAge();
        per2.getName();
        per2.setAge(17);
        per2.setName("mt");


        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
        System.out.println(per4);

    }

}

import javax.imageio.plugins.jpeg.JPEGImageReadParam;

/**
 * 代码块：1、实例代码快/构造代码块
 *        2、静态代码块
 *        3、本地代码块
 *
 * 注意：1、静态的内容，只能被执行一次，且是最早被执行的
 *      2、如果静态成员变量、静态方法都是静态的，根据其定义的先后顺序进行访问
 *      3、静态的方法和静态的成员是不依赖于对象的，可以直接由-- 类名.静态成员变量/静态成员方法 --进行访问静态成员变量/静态成员方法
 *         如果静态方法里面访问了实例成员变量，那么这个实例成员变量/方法是依赖对象的，但是静态成员变量/方法不依赖。
 *
 *         访问静态成员变量/静态成员方法：类名.静态成员变量名/静态成员方法名
 *         访问实例成员变量/实例成员方法：对象的引用.静态成员变量名/静态成员方法名 --- 必须创建一个对象Student stu = new Student();
 *
 *
 */
class Student{

    /**
     * 实例成员变量和静态成员变量
     */
    public String name;
    public int age;
    public static String sex;

    public void sleep(){
        System.out.println("sleep()!");
    }

    public static void eat(){
        System.out.println("eat()!");
    }

    /**
     * 静态成员方法中不能访问实例成员变量
     * @param name
     * @param age
     */
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    static{

        //this.name = "abc";
        //name = "ccc";
    }

    /**
     * 验证Static
     */
    public static int count  = 0;

    static {
        count=99;
        count1 = 88;
    }
    public static int count1  = 0;

    /**
     * 代码快
     */
    static{
        System.out.println("静态代码块------------");
    }

    {
        System.out.println("实例代码快/构造代码块-------------");
    }

    public Student() {
        {
            System.out.println("本地代码块------------");
        }
    }
}
public class Demo_2 {

    /**
     * 实例成员变量和静态成员变量的访问
     */
    public static void main(String[] args) {
        //实例成员变量和方法
        Student stu = new Student();
        System.out.println(stu.age);
        System.out.println(stu.name);
        stu.sleep();

        //静态成员变量和方法
        System.out.println(Student.sex);
        Student.eat();
    }

    /**
     * 验证如果静态成员变量、静态方法都是静态的，根据其定义的先后顺序进行访问
     */
    public static void main2(String[] args) {
        System.out.println(Student.count);//打印99
        System.out.println(Student.count1);//打印0

    }
    /**
     * 静态内容，只会被执行一次，且是最早被执行的
     */
    public static void main1(String[] args) {
       Student stu = new Student();
       System.out.println("-----------------");
       Student stu1 = new Student();

    }
}