一、Java的类：

Java的类是Java的基本概念了，基本的定义语法我就不提了，自己也不会忘了的，下面分成几个模块介绍：

1、Java的类定义时候的修饰符

2、Java的类的继承与派生

二、Java类定义的时候的修饰符：

说白了其实基本上就是变量的一些修饰符，因为java没有类外的变量或者方法可以用

1、public、protected和private

 1 /*
 2 第一类protected private public
 3 public所有类可见
 4 protected 包内的所有类和任何位置的子类可见
 5 private 只在本类内可见
 6 以上均可以修饰属性、方法 ，public可以修饰类，但是一个java文件只能有一个public类
 7 */
 8 import java.io.*;
 9 
10 class person{
11     public String pName;
12     private String pId;
13     enum Gender {Male,Female};
14     protected Gender pGender;
15     protected int pAge;
16     
17     person(String name,String id,int gender,int age) throws Exception{
18         this.pName = name;
19         this.pId = id;
20         if(gender == 0) {
21             this.pGender = Gender.Male;
22         }
23         else if (gender == 1) {
24             this.pGender = Gender.Female;
25         }
26         else {
27             throw new Exception("Gender Error!");
28         }
29         this.pAge = age;
30     }
31     
32     protected String getId() {
33         return this.pId;
34     }
35     
36     public void setName(String name) {
37         this.pName = name;
38     }
39     
40     private void sick() {
41         System.out.println("sick");
42     }
43 }

2、static静态变量（属性）与静态函数（方法）

静态指不依赖任何实例的变量或者方法，属于类的全体实例共享的，所以也不是独立的。如果有protected修饰就有点类似python里面的类变量，用public修饰就成了全局变量了，使用private修饰就成了带_ _的类变量了（但是其外部访问永远无法做到）。静态变量可以被静态与非静态方法调用。但是静态方法只能调用类中静态变量和自己参数中的变量。

1 public static int a = 1;
2 private static int b = 2;
3 protected static int c = 3;
4 public static void run(){}
5 private static void run(){}
6 protected static void run(){}

3、final

final是只能被赋值一次的变量，只能被继承不能被重载的方法，和不能被继承的类（所有成员方法都是final方法）

1 public final a = 1;//后面再也不能给a赋值了
2 public final void run(){}//子类可以继承但不能重载run方法
3 final class A{}//不能被继承的类，所有成员方法都是final方法 

三、java的继承与派生

1、单继承

 1 import java.io.*;
 2 
 3 class person{
 4     public String pName;
 5     private String pId;
 6     enum Gender {Male,Female};
 7     protected Gender pGender;
 8     protected int pAge;
 9     
10     person(String name,String id,int gender,int age) throws Exception{
11         this.pName = name;
12         this.pId = id;
13         if(gender == 0) {
14             this.pGender = Gender.Male;
15         }
16         else if (gender == 1) {
17             this.pGender = Gender.Female;
18         }
19         else {
20             throw new Exception("Gender Error!");
21         }
22         this.pAge = age;
23     }
24     
25     protected String getId() {
26         return this.pId;
27     }
28     
29     public void setName(String name) {
30         this.pName = name;
31     }
32     
33     private void sick() {
34         System.out.println("sick");
35     }
36 }
37 
38 class student extends person{
39     private int sScore;
40     public String sSchool;
41     public int sLevel;
42     student(String name,String pid,int gender,int age,int score,String school,int level) throws Exception{
43         super(name,pid,gender,age);
44         this.sScore = score;
45         this.sLevel = level;
46         this.sSchool = school;
47     }
48     public void showinfo() {
49         System.out.println(this.pName);
50         System.out.println(this.getId());
51         System.out.println(this.pGender);
52         System.out.println(this.pAge);
53         System.out.println(this.sSchool);
54         System.out.println(this.sLevel);
55         System.out.println(this.sScore);
56     }
57 }

（1）知识点1：重载构造方法：

自己的变量自己管，父类的变量super()传。子类的构造函数参数要包含父类构造函数中的参数，并把父类的那部分参数传入super()进行调用。

（2）知识点2：

重载方法后优先使用重载的方法。

2、接口与抽象类：

（1）接口是一种特殊类：

 1 /*@Override是重载父类或者接口的修饰符，编译器识别到这个之后，可以在编译时帮助检查父类是否由此方法*/
 2 interface jiekou{
 3   //只能有静态全局常量public static final xxxx和抽象方法  
 4 }
 5 /*
 6 1、接口必须有子类
 7 2、子类可以继承多个接口
 8 3、接口中的子类如果不是抽象类，必须重写接口的所有方法
 9 4、接口本身可以继承多个接口extends，接口不能继承抽象类和普通类
10 5、接口可以实例化但是必须通过子类的实例的反转实现
11 */
12 //X类继承A和B两个接口
13 X x = new X();//实例化子类对象
14 A a = x;//向上转型
15 B b = x;//向上转型

（2）抽象方法与抽象类：

（2.1）延伸接口中的抽象方法的抽象概念，此概念也可以到抽象类

这就是一个方法的定义，只有函数的抽象概念没有实际的实现。必须要到子类中给与重载实现。

（2.2）抽象类：

 1 /*
 2 抽象类:
 3 1、拥有抽象函数的类就叫抽象类，与接口不同可以有普通的成员变量和方法，但是至少有一个抽象方法。
 4 2、继承抽象泪的子类如果不是抽象类那么必须重载实现父类的抽象方法。所以抽象方法必须public或者protected的。
 5 3、抽象类不能创建实例。
 6 4、抽象类可以继承抽象类。
 7 */
 8 abstract class ClassName {
 9     abstract void fun();//至少有一个抽像函数；
10 }

（3）总结一下多继承：

（3.1）前提：

　#接口是一种特殊的抽象类（只有全局静态变量和抽象函数的抽象类）

   #接口必须被继承才有用（不能直接实例化）

　#接口中的方法都必须重载后才能使用

   #抽象类可以继承抽象类（只能继承一个，可以继承接口，可以继承多个）  

   #接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法

   #抽象类必须继承才能用（不能直接实例化）

（3.2）多继承

   #普通类可以继承普通类和抽象类（但是一个只能继承一个），可以继承接口（多个）。

   #抽象类可以继承抽象类（一个），可以继承接口（多个）。

   #接口可以继承接口（多个）

1 interface A extends B,C{}
2 abstract class D{}
3 abstract class E extends D implements A,B,C{}
4 class F{}
5 class G extends F implements A,B,C{}
6 class H extends E {}