使用private关键字去修饰变量和方法，使变量和方法只能够在本类当中使用，但他会给本类提供接口，让其他类来间接访问本类当中的数据。
public class Animal{ private String name; private int age; public void setName(String name){ this.name=name; } public String getName(){ return name; } public void setAge(int age){ if (age<0){ System.out.println("error"); }else{ this.age=age; } } public int getAge(){ return age; } public void introduce(){ System.out.println("我叫"+name+"今年"+age); } public static void main(String[] args){ Animal dog=new Animal(); dog.setAge(-18); dog.setName("daHuang"); dog.introduce(); } }
继承 注意：
子类拥有父类除 private 以外的所有属性和方法（就是代码）。
子类可以拥有自己的属性和方法。
子类可以重写实现父类的方法。
Java 中的继承是单继承，一个类只有一个父类。
语法格式
class 子类 extends 父类{}
public class Animal {public int legNum; //动物四肢的数量//类方法public void bark() { System.out.println("动物叫！");}}//Dog类继承Animal类public class Dog extends Animal {}public class Test{public static void main(String[] args) { Dog a = new Dog(); a.legNum = 4; a.bark();}}
多态 抽象类 抽象类定义：
1.抽象类和抽象方法必须都有abstract
2.抽象类不能被实例化，也就是不能new关键字去产生对象。
3.抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
注意：
抽象类当中可以有普通方法和抽象方法。
抽象方法
抽象方法就是在方法的前面加上 abstract，他也有普通方法的功能和属性。
其父类必须是抽象类（再类名前面加上abstract），继承的子类必须重写父类中的抽象方法。
接口用于描述类所具有的功能（就是更加抽象的类），而不提供功能的实现。
接口语法：
修饰符 interface A extends 接口1，接口2{ public static final 数据类型 成员名称 = 常量； //数据成员必须赋初值，其中public static final 可以不写 abstract 返回值的数据类型 方法名称(参数..); //抽象方法，注意在抽象方法里，没有定义方法主体 default 返回值的数据类型 方法名称(参数..){} static 返回值的数据类型 方法名称(参数...){} }以上方法都有public都可以默认不行，会自动添加。
访问接口：
全局常量：实现类.常量
静态方法：接口名.方法名
抽象方法和默认方法 ： 通过接口 的实现类 的对象来访问
注意：
implements实现接口，并实现接口中的全部抽象函数。其中实现的类必须把接口中的方法全都去重写。
接口的实现：
class 类名称 [extends 父类名] implements 接口A,接口B { ...}接口不能用于实例化对象。
public class Animal { public static void main(String[] args) { System.out.println(dogName.ID);//全局常量获取:实现类. dogName daHuang=new dogName(); daHuang.breathe(); //抽象函数获取:实现类对象. daHuang.getType("金毛"); //默认函数获取：实现类对象. System.out.println(Dog.getID()); //静态函数获取:接口名. }}
多态 多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态
Animal a = new Animal(); //a是父类的引用指向的是本类的对象
Animal b = new Dog(); //b引用的数据类型和对象的数据类型不一致
为啥会出现多态？
b调用方法的时候实际调用的是Dog()重写后的方法
多态条件
1、b是父类的引用指向的是子类的对象
2、调用的方法有重写
public class Dog { public void blak(){ System.out.println("wangwang"); }} public class Animal extends Dog{ String name; int age; public void blak(){ System.out.println("动物叫"); } public static void main(String[] args){ Dog daHuang=new Animal(); daHuang.blak();//动物叫 }}
内部类 非静态类非静态内部类可以直接在一个类里面定义
public class Animal{ private String name; float hp; String blak; // 非静态内部类，只有一个外部类对象存在的时候，才有意义 class BattleScore{ int kill; int die; int assit; public void legendary(){ if(kill>=8) System.out.println(name+"咬了"); else System.out.println(name+"被咬了"); } } public static void main(String [] args){ Animal dog=new Animal(); dog.name="daHuang"; // 实例化内部类 BattleScore score=dog.new BattleScore(); score.kill=9; score.legendary(); }}调用方式：父类引用.子类对象如 dog.new BattleScore();
静态内部类静态内部类 不需要一个外部类的实例为基础，可以直接实例化
语法：new 外部类.静态内部类();
因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法
定义在方法中的类，有效范围在方法之中。
局部内部类可以访问外部类的所有成员和方法，但是内部类的成员和方法仅限于此方法中使用。
public class Animal{ int m=1; void test1(){ System.out.println("外部成员类方法"); } void test2() { //定义局部内部类Inner，在局部内部类中访问外部类变量和方法 class Inner { int n=1; void show() { System.out.println("外部静态变量m=" + m); test1(); } } //在局部内部类的方法中，调用局部内部类变量和方法 Inner inner=new Inner(); System.out.println("局部内部类变量n="+inner.n); inner.show(); } public static void main (String [] args){ Animal inner=new Animal(); inner.test2(); }}
匿名类（没有名字的类） 如果改方法的参数数一个类型，通常使用匿名类。
匿名内部类创建语法
interface dog{ void shout();}public class Animal{ public static void main(String [] args){ String name="xiaohua"; animalShout ( new dog(){ //实现shout()方法 public void shout(){ System.out.println(name+"汪汪"); } }); } public static void animalShout(dog an){ an.shout(); }}