面向对象

类的格式：

class  Student{
    //定义变量
    int age;
    String name;

    //定义方法
    public void eat(){

        System.out.println("eat");
    }
}

属性的调用：

class  Student{
    //定义变量
    int age;
    String name;

    //定义方法
    public void eat(){

        System.out.println("eat");
    }
}


class  StudentDemo{
    public  static void main( String[] args){
        Student s = new Student();

        //属性赋值
        s.age =19;
        s.name = "zym";
        System.out.println(s.age+s.name);
        //函数调用
        s.eat();


    }

}

成员变量和局部变量：

区别：

成员变量和局部变量的区别?
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

类参数的问题：

//形式参数是基本类型
class Demo {
    public int sum(int a,int b) {
        return a + b;
    }
}

//形式参数是引用类型
class Student {
public void show() {
System.out.println("我爱学习");
}
}

class StudentDemo {
//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
s.show();
}
}

匿名对象：

就是没有名字的对象，有点想python中的lamba。

应用场景：

A:调用方法，仅仅只调用一次的时候。
注意：调用多次的时候，不适合。
那么，这种匿名调用有什么好处吗?
有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递

class Student {
    public void show() {
        System.out.println("我爱学习");
    }
}

class StudentDemo {
    public void method(Student s) {
        s.show();
    }
}

class NoNameDemo {
    public static void main(String[] args) {
        //带名字的调用
        Student s = new Student();
        s.show();
        s.show();
        System.out.println("--------------");
        
        //匿名对象
        //new Student();
        //匿名对象调用方法
        new Student().show();
        new Student().show(); //这里其实是重新创建了一个新的对象
        System.out.println("--------------");
        
        
        //匿名对象作为实际参数传递
        StudentDemo sd = new StudentDemo();
        //Student ss = new Student();
        //sd.method(ss); //这里的s是一个实际参数
        //匿名对象
        sd.method(new Student());
        
        //在来一个
        new StudentDemo().method(new Student());
     }
}

封装：

隐藏对象的属性和实现细节，仅对外提供公共访问方式。

用私有修饰符 private实现

Private关键字：

可以修饰成员变量和方法，被修饰之后只能被本类进行访问，或者操作

也可以给构造方法进行pricate修饰，可以让类无法被实例化，只能使用类名进行

方法的调用。

this关键字：

相当于python类中的self,

方法被那个对象调用，this就代表那个对象。

可以解决局部变量隐藏成员变量

class Student {
    private String name;
    private int age;
    
    public String getName() {
        return name; //这里其实是隐含了this
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

this调用构造方法：

public class Person1{
    private String name;
    
    public Person1(){
        this.print();
    }
    
    
    public void print(){
        System.out.println("xxx");
    }
    
    public Person1(String name){
        this();//调用无参构造方法必须在第一行
    }
    
    
    
        }

构造方法：

给对象的数据进行初始化

格式：

方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值

构造方法的注意事项：

如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

因为构造是一个方法，所以也有重载

class Student {
    private String name;
    private int age;

    public Student() {
        //System.out.println("我给了，你还给不");
        System.out.println("这是无参构造方法");
    }
    
    //构造方法的重载格式
    public Student(String name) {
        System.out.println("这是带一个String类型的构造方法");
        this.name = name;
    }
    
    public Student(int age) {
        System.out.println("这是带一个int类型的构造方法");
        this.age = age;
    }
    
    public Student(String name,int age) {
        System.out.println("这是一个带多个参数的构造方法");
        this.name = name;
        this.age = age;
    }
    
    public void show() {
        System.out.println(name+"---"+age);
    }
}

static关键字：

针对多个对象有共同的这样的成员变量值的时候，

public static xxx

相当于是个全局变量，也叫静态变量。

Java就提高了一个关键字来修饰：static。

class Person {
    //姓名
    String name;
    //年龄
    int age;
    //国籍
    //String country;
    static String country;

    public Person(){}

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

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

    public void show() {
        System.out.println("姓名："+name+",年龄："+age+",国籍："+country);
    }
}

class PersonDemo {
    public static void main(String[] args) {
        //创建对象1
        Person p1 = new Person("邓丽君",16,"中国");
        p1.show();

        //创建对象2
        //Person p2 = new Person("杨幂",22,"中国");
        //p2.show();
        Person p2 = new Person("杨幂",22);
        p2.show();

        //创建对象3
        //Person p3 = new Person("凤姐",20,"中国");
        //p3.show();
        Person p3 = new Person("凤姐",20,"美国");
        p3.show();

        System.out.println("--------------------------");
        p3.country = "美国";


        p1.show();
        p2.show();
        p3.show();

    }
}

特点：

/*
    static的特点：(它可以修饰成员变量，还可以修饰成员方法)
        A:随着类的加载而加载
            回想main方法。
        B:优先于对象存在
        C:被类的所有对象共享
            举例：咱们班级的学生应该共用同一个班级编号。
            其实这个特点也是在告诉我们什么时候使用静态?
                如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
            举例：
                饮水机(用静态修饰)
                水杯(不能用静态修饰)
        D:可以通过类名调用
            其实它本身也可以通过对象名调用。
            推荐使用类名调用。
            
            静态修饰的内容一般我们称其为：与类相关的，类成员
　　注意：非static声明的方法可以去调用static声明的属性或者方法。
         但是static声明的方法是不能调用非static类型声明的属性或方法的。

*/
class Student {
    //非静态变量
    int num = 10;
    
    //静态变量
    static int num2 = 20;
}

内存的进行过程：

 

静态方法的注意事项：

 static关键字注意事项

在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：
静态只能访问静态。

 静态变量联合成员变量的区别：

所属不同：

静态变量属于类，所以也称为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

内存中的位置不同：

静态变量存储于方法区的静态区

成员变量存储于内存

内存出现的时间不同：

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同：

静态变量可以通过类名调用，也可以通过对象调用。

成员变量只能通过对象名调用

main方法的格式:

main方法的格式讲解：
public static void main(String[] args) {...}

public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。
String[] args:这是一个字符串数组。值去哪里了?
这个东西到底有什么用啊?怎么给值啊?
这个东西早期是为了接收键盘录入的数据的。
格式是：
java MainDemo hello world java

帮助文档的制作：

/**
* 这是针对数组进行操作的工具类
* @author xxx
* @version yyy
*/
public class ArrayTool {
    
    //把构造方法私有，外界就不能在创建对象了
    /**
    * 这是私有构造
    */
    private ArrayTool(){}

    /**
    * 这是遍历数组的方法，遍历后的格式是：[元素1, 元素2, 元素3, ...]
    * @param arr 这是要被遍历的数组
    */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
    
    /**
    * 这是获取数组中最大值的方法
    * @param  arr 这是要获取最大值的数组
    * @return 返回数组中的最大值
    */
    public static int getMax(int[] arr) {
        int max = arr[0];
        
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        
        return max;
    }
    
    /**
    * 获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1
    * @param arr 被查找的数组 
    * @param value 要查找的元素
    * @return 返回元素在数组中的索引，如果不存在，返回-1
    */
    public static int getIndex(int[] arr,int value) {
        int index = -1;
        
        for(int x=0; x<arr.length; x++) {
            if(arr[x] == value) {
                index = x;
                break;
            }
        }
        
        return index;
    }
}

之后的查看方法可以使用，例如：

C:> javadoc -d C:homehtml -sourcepath C:homesrc java.awt java.awt.event

-d为你指定生成帮助文件的目录，没有他会给你创建，-sourcepath是源文件的路径，

后面可以是1个或者多个文件。

之后进入那个目录，查看index.html的那个文件。

代码块

代码块：在Java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为

局部代码块:

局部位置,用于限定变量的生命周期。方法中定义的代码块

构造代码块:

在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。

静态代码块:

在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。

class Code {
    static {
        int a = 1000;
        System.out.println(a);
    }

    //构造代码块
    {
        int x = 100;
        System.out.println(x);
    }
    
    //构造方法
    public Code(){
        System.out.println("code");
    }
    
    //构造方法
    public Code(int a){
        System.out.println("code");
    }
    
    //构造代码块
    {
        int y = 200;
        System.out.println(y);
    }
    
    //静态代码块
    static {
        int b = 2000;
        System.out.println(b);
    }
}

class CodeDemo {
    public static void main(String[] args) {
        //局部代码块
        {
            int x = 10;
            System.out.println(x);
        }
        //找不到符号
        //System.out.println(x);
        {
            int y = 20;
            System.out.println(y);
        }
        System.out.println("---------------");
        
        Code c = new Code();    
        System.out.println("---------------");
        Code c2 = new Code();
        System.out.println("---------------");
        Code c3 = new Code(1);
    }
}

代码块的执行顺序：

静态代码块 -- 构造代码块 -- 构造方法
静态代码块：只执行一次，因为随着类的加载而加载
构造代码块：每次调用构造方法都执行，对象方法

继承：

继承的格式：

使用关键字extends 类

class 子类名 extends 父类名 {}

class Father {
    public void method(){
        System.out.println("我是老子");
    }
}

class Son extends Father {}

这里注意java中没有多继承的概念，只有单继承。

继承的利与弊：

好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生了关系，是多态的前提

类与类产生了关系，其实也是继承的一个弊端：
类的耦合性增强了。

开发的原则：低耦合，高内聚。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

注意：

子类只能继承父类的非私有变量，方法。

子类不能继承父类的构造方法，但是需要使用super来进行访问。(默认的是有super()的)

变量名字一样的话，后面的覆盖前面的。

super方法和this方法的区别：

this和super的区别?
分别是什么呢?
this代表本类对应的引用。
super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

怎么用呢?
A:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
B:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
C:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法

继承中的构造方法的关系：

继承中构造方法的关系
A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
B:为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。

注意：子类每一个构造方法的第一条语句默认都是：super();

继承中的构造方法的关系(父类没有无参数的构造方法)：

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A:在父类中加一个无参构造方法
B:通过使用super关键字去显示的调用父类的带参构造方法
C:子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。

注意事项：
this(...)或者super(...)必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

class Father {
    /*
    public Father() {
        System.out.println("Father的无参构造方法");
    }
    */
    
    public Father(String name) {
        System.out.println("Father的带参构造方法");
    }
}

class Son extends Father {
    public Son() {
        super("随便给");
        System.out.println("Son的无参构造方法");
        //super("随便给");
    }
    
    public Son(String name) {
        //super("随便给");
        //this();
        System.out.println("Son的带参构造方法");
    }
    public Son(int age) {
        //super("随便给");
        this();
        System.out.println("Son的带参构造方法");
    }
}

类继承方法的重写：

方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。

如何使用父类的功能呢?通过super关键字调用

这里注意：

子类重写父类方法的时候，最好声明一模一样。

@Override

帮你检验你的重写的方法是否覆盖了父类的方法。

类的初始化过程：

一个类的初始化过程
成员变量的初始化
默认初始化
显示初始化
构造方法初始化

 内部类：

在类内部也可以定义另一个类。如果在类Outer的内部再定义一个类Inner，此时类Inner就称为内部类，而类Outer则称为外部类。

标识符 class 外部类的名称{
        // 外部类的成员
        标识符 class 内部类的名称{                                  
            // 内部类的成员
        }
    } 

static关键字修饰：

用static可以声明属性或方法，而用static也可以声明内部类，

用static声明的内部类则变成外部类，但是用static声明的

内部类不能访问非static的外部类属性。

在外部访问内部类：

外部类.内部类 内部类对象 = 外部类实例.new 内部类() ;

 单例模式：

class Person1{
    private Person1 P = new Person1();

    public Person1(){};
    public Person1 get_obj(){
    //这里注意，这种类型是表示返回的是一个独享
        return P;

    }

        };


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



    }

class Person1{
    static private Person1 P = null;

    private Person1(){};

    public static Person1 get_obj(){
        if (P==null){
            P = new Person1();
        }
        return P;
    }
        };


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

    Person1 s = Person1.get_obj();

    }
}