通常应禁止直接访问一个对象数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
属性私有，get/set
代码演示
//学生类 public class Student { //成员变量 //姓名 private String name; //年龄 private int age; //set get //alt + insert public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } //成员方法 public void study(){ System.out.println("键盘敲烂 月薪过万"); } public void eat(){ System.out.println("学生要吃有营养的饭"); } } //测试类 public class Test { public static void main(String[] args) { //创建对象 Student s = new Student(); //给成员变量赋值 s.setName("小明"); s.setAge(25); //获取成员变量的值 System.out.println(s.getName() + " " + s.getAge()); } }
继承的本质就是对某一批类的抽象，从而实现对现实世界美好的建模
extends的意思是"拓展"。子类是父类的拓展
Java中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该是具有"is a"的关系
在Java中所有的类都默认直接或者间接继承Object类
//人类（父类） public class Person { //成员变量 String name; int age; //成员方法 public void eat(){ System.out.println("好好吃饭 天天长大"); } public void sleep(){ System.out.println("好好睡觉"); } } //学生类（子类） public class Student extends Person{ //自动继承父类的成员 } public class Test { public static void main(String[] args) { //创建学生对象 Student s = new Student(); //使用成员变量 s.name = "小明"; s.age = 28; //使用成员方法 s.eat(); s.sleep(); } }
变量和方法的访问规则(重名情况):
this:优先访问本类的成员变量和成员方法
super:优先访问父类的成员变量和成员方法
this和super访问构造方法：
写法：
super()用来访问父类的构造方法
this()用来访问本类的其他构造方法
注意事项：
this()和super()都必须放在构造方法的第一行，所以在一个构造方法中只能写一个this()或super()
常规写法：
子类的空参调用父类的空参
子类的有参调用父类的有参
成员变量和成员方法：--------------------- public class Person { //成员变量 String name = "王健林"; //成员方法 public void eat(){ System.out.println("父类的吃饭方法"); } } public class Student extends Person { //成员变量 String name = "王思聪"; //方法 public void show(){ //局部变量 String name = "王可可"; System.out.println(name); //"王可可" System.out.println(this.name); //"王思聪" System.out.println(super.name); //"王健林" //调用方法 eat(); //就近原则 this.eat(); //和上面写法是一样的 super.eat();//访问父类的成员方法 } } 构造方法：------------------------------- //父类 public class Person { String name; int age; //构造方法 public Person() { System.out.println("父类空"); } public Person(String name, int age) { this.name = name; this.age = age; System.out.println("父类有"); } } //子类 public class Student extends Person { //构造方法 //空参构造 public Student() { //访问父类的空参构造 //super(); System.out.println("子类空"); } //有参构造 public Student(String name, int age) { //访问父类的有参构造 super(name, age); System.out.println("子类有"); } }
即同一个方法可以根据发送对象的不同而采用不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
要有继承或者是实现
要有方法的重写
注意：多态是方法的多态，属性没有多态性
成员变量
编译看左边(父类)，运行看左边(父类)
成员方法
编译看左边(父类)，运行看右边(子类)
public class Person { String name = "王健林"; public void eat(){ System.out.println("王健林吃米其林"); } } public class Student extends Person { String name = "王思聪"; public void eat(){ System.out.println("王思聪吃热狗"); } } public class Test { public static void main(String[] args) { //一个学生是一个人 Person p = new Student(); //访问变量 //编译看左边(父类)，运行看左边(父类) System.out.println(p.name); //访问方法 //编译看左边(父类)，运行看右边(子类) p.eat(); } }
弊端
不能调用子类的特有方法，只能调用父类中定义的共性方法
好处
示例代码
public class Test { public static void main(String[] args) { //创建对象 Sheep s = new Sheep(); method(s); Dog d = new Dog(); method(d); Cat c = new Cat(); method(c); } //使用多态 //提高了代码的扩展性 public static void method(Animal a){ //相当于： Animal a = new Sheep(); System.out.println("有请开始叫："); //相当于： Animal a = new Dog(); a.jiao(); //相当于： Animal a = new Cat()); } /* 不使用多态 //定义方法 public static void method(Sheep s){ System.out.println("有请开始叫："); s.jiao(); } //定义方法 public static void method(Dog d){ System.out.println("有请开始叫："); d.jiao(); } //定义方法 public static void method(Cat c){ System.out.println("有请开始叫："); c.jiao(); } */ }
向上转型
Person p = new Student();
向下转型
把父类类型转成子类类型
Student ss =(Student) p;
类型转化异常
ClassCastException：类型转换异常
做了不正确的向下转型。
概念:
在生活中接口就是规范，在java中接口是一种数据类型，他的作用也相当于是规范。
格式：
public interface 接口名{ }
格式：
public class 类名 implements 接口{ } //接口被实现,实现类也能够拥有接口的成员
抽象方法：
//抽象方法 public abstract void method();
//静态方法(直接用接口名调用) public static void method2(){ System.out.println("静态方法"); }
//默认方法(让子类直接使用) public default void method3(){ System.out.println("默认方法"); }
//私有方法(如果本类中有重复的代码,就可以写在私有方法中) private void method4(){ System.out.println("私有方法"); }
//定义变量 int a = 10;
类可以继承类，java中只支持单继承。(一个类只能有一个父类,一个类只能有一个亲爹)
类可以实现接口，java中支持多实现。(一个类可以实现多个接口，一个类可以有多个干爹)
接口和接口是继承关系，java中的接口是多继承。(平时写代码不会遇到)
在开发中遇到最常见/最复杂的写法：
一个类在继承一个父类的情况下再实现多个接口
QQQ这个类继承了CCC类还实现了AAA和BBB两个接口
public class QQQ extends CCC implements AAA,BBB{ }
原文：https://www.cnblogs.com/SunJunchen/p/14084950.html