封装：在类的属性设置时 使用private将数据隐藏。不允许使用a.xingming来调用数据，可以设置get和set函数来对数据进行查看和修改（在其中添加if的判断语句来控制该参数的修改权限和读取权限）。
public class vip {private String xingming;/*alt + insert 自动生成get和set相关代码*/public String getXingming() {return xingming;}public void setXingming(String xingming) {this.xingming = xingming;}}
继承：继承小明继承了人类的所有东西其中包括属性和方法，子类可以对父类的东西进行重新改写；子类只能继承一个父类；父类可以被多个子类继承；
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
class 父类 {}class 子类 extends 父类 {}
下面给出一个事例。
public class people {public int shengao = 170;public void chifan(){System.out.println("我在吃饭");}}
public class xiaoming extends people {private int shengao=160;public void chifan(){//修改继承的方法，将吃饭的方法改为吃排骨System.out.println("我在排骨");}public void seeshengao(){System.out.println("小明的身高"+this.shengao);System.out.println("人们的身高" + super.shengao);}}
可以在子类中使用this调用子类中的参数；使用super调用父类中的参数。
需要注意的是 Java 不支持多继承，但支持多重继承。Class A 继承 Class B Class C继承B 则C就继承了A的属性和方法。
继承的特性
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类
final关键字
final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
构造器
子类不继承父类构造器
方法重写
写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
class Animal{public void move(){System.out.println("动物可以移动");}}class Dog extends Animal{public void move(){System.out.println("狗可以跑和走");}}public class TestDog{public static void main(String args[]){Animal a = new Animal(); // Animal 对象Animal b = new Dog(); // Dog 对象a.move();// 执行 Animal 类的方法b.move();//执行 Dog 类的方法}}
多态
A:多态概述
某一个事物，在不同时刻表现出来的不同状态。
举例： Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();
B:多态前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();
好处：
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
好处的示例
public class MyTest {public static void main(String[] args) {//使用多态的好处：//1.提高了代码的复用性，是靠继承保证的//2.提高了代码的扩展性。Animal cat = new cat();//使用多态之后的 MyUtils.test(cat);Animal dog = new Dog();//不使用多态的时候MyUtils.test(dog);/*Dog dog = new Dog();//不使用多态的时候MyUtils.test(dog);*/}}public class Animal {public void eat() {System.out.println("吃饭");}}public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}}public class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨头");}}public class MyUtils {//私有构造，外界就无法创建，该类对象private MyUtils() {}public static void test(Animal an) {// Animal an=cat 父类引用指向子类对象// Animal an=dog 父类引用指向子类对象//多态的方式：在调用成员方法的时候，编译看左边，运行看右边//面向父类或接口 编程an.eat();//an.catchMouse();Cat cat= (Cat) an;cat.catchMouse();}/*不使用多态调用方法的public static void test(Cat cat) {cat.eat();}public static void test(Dog dog) {dog.eat();}public static void test(Tiger tiger) {tiger.eat();}public static void test(Mouse mouse) {mouse.eat();}*/}
方法调用和属性的示例
public class MyTest {public static void main(String[] args) {// 孔子装爹/* 孔子爹，是一名Java讲授，讲授Java特别有名，张三这个学员 慕名而来，他把孔子爹请到家里去给他讲授Java,这时候就剩孔子一个人在家，李四也想学Java，李四也来，孔子家里面去请孔子爹孔子爹不在家，孔子又不想失去这个学员，孔子经过一番乔装打扮，扮成他爹的模样，去给李四讲课* 孔子讲完课之后，他觉得太类了，很不容易，他要卸下装扮做回自己，玩了一把吃鸡游戏*** */孔子爹 k爹 = new 孔子();System.out.println(k爹.age);//打印60k爹.teach();//将论语//向下转型，做回自己孔子 kz = (孔子) k爹;System.out.println(kz.age);//打印30kz.palyGame();//玩吃鸡游戏}}class 孔子爹 {int age = 60;public void teach() {System.out.println("讲授Java");}}class 孔子 extends 孔子爹 {int age = 30;@Overridepublic void teach() {System.out.println("讲论语");}public void palyGame() {//子类自带方法System.out.println("玩吃鸡游戏");}}
抽象类
抽象类的概述及其特点
A:抽象类概述
回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。
同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
B:抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
public class MyTest {public static void main(String[] args) {//abstract 抽象的 可以修饰类，修饰方法//1.abstract 修饰类，此类就不能直接实例化// Animal animal = new Animal();//2.abstract 修饰方法：修饰的方法，要求子类必须重写}}abstract class Animal{public abstract void eat();/*{System.out.println("吃饭");}*/}class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨头");}}class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}}
public class MyTest2 {public static void main(String[] args) {//抽象类的注意语法//1.一个类里面，有了抽象方法，那么这个类，必须为抽象类//2.一个抽象类里面，可以不可以没有抽象方法？可以//3.抽象类里可以有非抽象方法吗？可以//4.抽象类里面，有没有构造方法？有 为了在子类创建对象时完成父类数据的初始化//采用多态的方式来完成父类数据的初始化//抽象类成员变量的特点：1.可以定义成员变量，也可以定义常量A a = new B();System.out.println(a.AA);System.out.println(a.num);//抽象类，里面既可以定义抽象方法，又可以定义非抽象方法//抽象的方法，他是强制子类必须重写。非抽象方法 一般就是让子类继承下去用，当然子类可以重写非抽象方法}}abstract class A {//abstract 在方法中使用，能不能和下面的关键字一块使用// private abstract 矛盾 abstract 强制子类重写 private 限定后又无法重写// final abstract 矛盾 abstract 强制子类重写 final 重写不了// abstract static 矛盾int num = 20;public final int AA = 20;public A() {System.out.println("抽象类的空参构造执行了");}public abstract void show();public void hehe() {System.out.println("hehe");}}class B extends A {int num = 600;public B() {System.out.println("子类的空参构造执行了");}@Overridepublic void show() {}@Overridepublic void hehe() {super.hehe();}}
接口
接口概述
继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可
B:接口特点
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
d:接口的子类
1. 可以是抽象类。但是意义不大。
2.可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
public class MyTest {public static void main(String[] args) {//接口：用来定义事物的一些额外的扩展的功能，将来那类事物，想要具备，这些额外的功能，就可以实现这个接口//定义接口的语法 interface 接口名{}//类 implements 接口 是实现关系// 这个类，可以叫做接口的子类， 这个接口 可以叫做这个类的父接口//接口不能实例化，接口里面没有构造方法//作为接口的子类，有什么要求//1.要求子类必须重写接口中所有的抽象方法//2.如果你不想重写，你这个类可以为一个抽象类，将接口中的抽象方法继承即可}}public interface Fireinterface {//定义了一个接口//接口中的成员特点//接口中的成员变量：接口中的成员变量全是公共的静态常量//接口中的成员方法，全部是抽象方法，，不存在非抽象方法//接口中没有构造方法public abstract void fire();//接口中的方法，前面存在默认修饰 public abstractpublic static final int NUM = 200;int A = 600; //接口中成员变量 前面存在默认修饰符 public static final}class Cat implements Fireinterface {public void eat() {}@Overridepublic void fire() {System.out.println("猫学会了钻火圈");}}class Dog implements Fireinterface{@Overridepublic void fire() {System.out.println("狗学会了钻火圈");}}
注意：类与类的关系：继承关系 extends Java中只支持单继承
1.类与接口的关系：实现关系 implements 可以多实现 一个类可以实现多个接口
2. 接口和接口之间的关系：继承关系 extends 支持多继承 一个接口可以继承多个接口
3. 一个类在继承一个类时，同时也实现多个接口
示例
public class MyTest {public static void main(String[] args) {/* A:案例演示动物类：姓名，年龄，吃饭，睡觉。动物培训接口：跳高猫继承动物类狗继承动物类部分猫继承猫类并实现跳高接口部分狗继承狗类并实现跳高接口*/布鲁斯 bls = new 布鲁斯();an=bls;an.name="布鲁斯";an.age=58;System.out.println(an.name);System.out.println(an.age);an.eat();an.sleep();JumpInteface jumpInteface= bls;jumpInteface.jump();}}public abstract class Animal {public String name;public int age;public abstract void eat();public abstract void sleep();}public interface JumpInterface {void jump();}public class Dog extends Animal{@Overridepublic void eat() {System.out.println("吃饭");}@Overridepublic void sleep() {System.out.println("睡觉");}}public class 布鲁斯 extends Dog implements JumpInteface {@Overridepublic void eat() {System.out.println("布鲁斯吃牛排");}@Overridepublic void sleep() {System.out.println("布鲁斯睡沙发");}public void watchTV(){System.out.println("看电视");}@Overridepublic void jump() {System.out.println("布鲁斯学会了跳高");}}
