JAVA-类的相关知识

标准类制作

① 类名需要见名知意

② 成员变量使用private修饰

③ 提供至少两个构造方法

• 无参构造方法
• 带全部参数的构造方法

④ get和set方法

​ 提供每一个成员变量对应的setXxx()/getXxx()

⑤ 如果还有其他行为，也需要写上

this关键字的作用

this代表所在类的当前对象的引用（地址值），即代表当前对象。
类的非静态方法的形参里面都会默认带一个 类名 this

定义格式和使用

static是静态的意思。 static可以修饰成员变量或者修饰方法。

静态变量及其访问

有static修饰成员变量，说明这个成员变量是属于类的，这个成员变量称为类变量或者静态成员变量。 直接用 类名访问即可。因为类只有一个，所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。
静态变量/静态方法都属于类的，所以调用一般都是通过类名进行调用

继承

好处

1. 提高代码的复用性（减少代码冗余，相同代码重复利用）。
2. 使类与类之间产生了关系。

需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，但是Java中的子类是更加强大的。

继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。

子类不能继承父类的构造方法。

值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过getter/setter方法访问父类的private成员变量。

子父类中出现了同名的成员变量时，子类会优先访问自己对象中的成员变量。如果此时想访问父类成员变量如何解决呢？我们可以使用super关键字。

super访问父类成员变量

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于之前学过的 this 。

需要注意的是：super代表的是父类对象的引用，this代表的是当前对象的引用。

如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法。

方法重写

概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

@Override重写注解

• @Override:注解，重写注解校验！

• 这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。

• 建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

继承后子类构方法器特点:子类所有构造方法的第一行都会默认先调用父类的无参构造方法

• 子类构造方法的第一行都隐含了一个**super()**去调用父类无参数构造方法，**super()**可以省略不写。

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

继承的特点

1. Java只支持单继承，不支持多继承
2. 一个类可以有多个子类。
3. 可以多层继承。

多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。

内部类

1.成员内部类
可以理解为这个是外部类的成员方法和变量。可以去获取外部类的成员变量和方法。
在JDK16之后才可以在成员内部类里面定义静态的东西。
创建的方法：

 Outer.Inner inner = new Outer().new Inner();

获取内部类的函数里面的变量，内部类自己的变量，和外部类的同名变量的方法。

public class Outer {
    public String name;
    public class Inner{
        //JDK16之后才能定义静态的
        public String name;
        public void test(){
            String name = "123";
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(Outer.this.name);
        }
    }
}

2.静态内部类
可以理解为一种静态的方法，只可以访问外部的静态变量和静态方法。`

 statc_class.inner_class inner_class1 = new statc_class.inner_class();

静态内部类可以访问的静态方法和静态变量

public class statc_class {
    public String name = "aaa";
    static int age  = 11;
    public static class inner_class{
        public String name;
        public void test(){
            String name = "123";
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(statc_class.age);

        }
    }
}

3.匿名内部类
简化

泛型：限制变量的类型，类型变量建议用大写字母来表示

泛型类：

public class fanxing1<E > {
    public String name;
    
    public void Use(E e){
        
    }
}


class fanxing2<E,T> {
    public String name;

    public void Use(E e,T t){

    }
}
class fanxing3<E extends Animal> {
    public String name;

    public void Use(E e){

    }
}

泛型接口：同上面的泛型类

public interface  test<T> {
    public abstract void  use();
}

public class use implements test<use>{

    @Override
    public void use() {

    }
}

泛型方法：

 public static <T > T use(T t)
    {

        return t;
    }

泛型下限：

 public static <T extends Animal> T use(T t)
    {

        return t;
    }
    或者
  public static void use(ArrayList<? extends Animal> USE)
    {
    }

泛型上限：

public static void use(ArrayList<? super Animal> USE)
    {
    }

泛型：1.不支持基本数据类型，只支持对象类型，引用数据类型
2.泛型擦除：泛型只存在编译阶段，一旦生成了class文件就会消失

final：
修饰时为常量不可改变

 final int a1 = 10;
        a1 = 20;

修饰类时：该类不可被继承

 class student extends people{
        (报错）
    }
    final    class people{
        
    }

修饰方法时：该方法不可被重写

  class student extends people{
            public void use(){
                
            }
    }
    class people{

        public final void use(){
            
        }
    }

abstract：
1.抽象类里面不一定有抽象方法，但有抽象方法一定要定义为抽象类
2.定位为抽象方法是不可以有函数体的
3.抽象类不可以创造对象，如果不能重写所有的抽象方法就定义为抽象类
4.抽象类可以有普通函数，成员变量等，构造方法

class student extends people{
        @Override
        void use() {
        }
    }
    abstract class people{
       abstract void use();
    }

案例：

abstract class  Animal{
    private String name;

     public String getName() {
         return name;
     }

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

     abstract void cry();

 }

 class Dog extends Animal{

     @Override
     void cry() {
         System.out.println(this.getName()+"------");
     }
 }


class Cat extends Animal{

    @Override
    void cry() {
        System.out.println(this.getName()+"------");
    }
}

模板方法的设计模式;模板方法用final进行修饰防止子类将其修改了

接口：