OOP的本质就是：以类的方式组织代码，以对象的组织（封装）数据
抽象
三大特性：继承，封装，多态
静态方法 public 后跟static ，其他类可以通过类名直接调用这个类
非静态方法 没有static，其他类调用之前需要实例化这个类 new
对象类型 对象名字 = new 对象值；
//学生类 public class Student { ? //一个类只存在两个东西：属性，方法 //属性：字段 String name; int age; ? ? //方法 public void study(){ System.out.println(this.name+"学生在学习"); }
构造器：
1.与类名相同
2.没有返回值
作用：
1.new 本质在调用构造器
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造
?
Alt+Insert
高内聚，低耦合
追求类的内部数据操作细节自己完成，仅暴露少量方法给外部使用。
属性私有 private ，
private String name; private int id; private char sex; private int age;
提供一些可以操作这个属性的方法 public 的get / set 方法
//get获取这个数据 public String getName(){ return this.name; } ? //set给这数据设置值 public void setName(String name){ this.name = name; } ? public int getId() { return id; } ? public void setId(int id) { this.id = id; } ? public char getSex() { return sex; } ? public void setSex(char sex) { this.sex = sex; }
使用get/set方法即可调用私有属性。
输出 小明
同时，为了避免一些不合法的输入，可以在set方法中写一些语句进行判断
public int getAge() { return age; } ? public void setAge(int age) { //如果输入年龄超过标准，返回age = 3 if (150 < age || age < 0){ this.age = 3; }else { this.age = age; } }
封装的优点
提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统的可维护性增加了
子类继承了父类，就会拥有父类 public 的和默认无修饰符的全部方法！
但是根据封装的思想，可以用get/set方法让字类操作父类私有的属性和方法。
ctrl+h可以打开继承树的界面，方便查看
是所有类默认继承的类
super 调用父类的构造方法
super 必须出现在字类的方法或构造方法中
在调用子类的无参构造器时，默认也调用父类的无参构造器。super 和 this 不能同时调用构造方法！
当父类重写有参构造时，子类无法调用父类无参构造，但可以在无参构造中用super（）显示调用父类有参。
VS this：
代表的对象不同：
this： 本身调用者这个歌对象
super： 引用父类的对象
前提：
this： 没有继承也可以使用
super: 只能在继承条件下才可以使用
构造方法：
this（）；本类的构造
super（）；父类的构造
重写需要有继承关系，子类重写父类。
重写都是方法的重写，与属性无关
要求：
方法名必须相同
参数列表必须相同
修饰符：范围可以扩大： public > protected >Default > private
抛出的异常：范围，可以被缩小，但不能被扩大；
重写，子类的方法和父类必要一致；方法体不同！
为什么要重写？
父类的功能，子类不一定需要，或者不一定满足！
快捷键：Alt+Insert : @override;
多态注意事项：
多态时方法的多态，属性没有多态
父类与子类有联系，类型不同的 转换会报异常 ClassCastException
存在条件： 继承关系，方法需要重写，父类引用执行子类 Father f1 = new Son（）
static 方法，属于类，它不属于实例
final 常量；
private 修饰的不能重写
1 //Object > String 2 //Object > Person > Teacher 3 //Object > Person > Student 4 Object object = new Student(); 5 ? 6 //抽象出一个公式： 能不能编译通过 7 // System.out.println(X instanceof Y); 8 ? 9 System.out.println(object instanceof Student); //true 10 System.out.println(object instanceof Person); //true 11 System.out.println(object instanceof Object); //true 12 System.out.println(object instanceof Teacher); //false 13 System.out.println(object instanceof String); //false 14 ? 15 System.out.println("---------------------"); 16 Person person = new Student(); 17 ? 18 System.out.println(person instanceof Student); //true 19 System.out.println(person instanceof Person); //true 20 System.out.println(person instanceof Object); //true 21 System.out.println(person instanceof Teacher); //false 22 //Error:(45, 28) java: 不兼容的类型: com.wang.oop.demo05.Person无法转换为java.lang.String 23 System.out.println(person instanceof String); 24 ? 25 System.out.println("---------------------"); 26 Student student = new Student(); 27 ? 28 System.out.println(student instanceof Student); //true 29 System.out.println(student instanceof Person); //true 30 System.out.println(student instanceof Object); //true 31 //Error:(53, 28) java: 不兼容的类型: com.wang.oop.demo05.Student无法转换为com.wang.oop.demo05.Teacher 32 //Error:(54, 28) java: 不兼容的类型: com.wang.oop.demo05.Student无法转换为java.lang.String 33 System.out.println(student instanceof Teacher); 34 System.out.println(student instanceof String);
类型转换
1 //类型之间的转换：父高子低 , 子类转换为父类可能会丢失自己本来的一些方法 2 ? 3 // 高 低 4 Person person = new Student(); 5 ? 6 //student将这个对象转换为Student类型， 7 // 就可以使用Student类型的方法了！ 8 //简写 ((Student)person1).go(); 9 Student person1 = (Student) person; 10 person1.go(); 11 ((Student)person1).go();
定义静态属性或方法等，和类一起加载，可以直接 （类名 . 属性或方法名）使用
1 //关键词 abstract 构成抽象类 2 public abstract class Action { 3 ? 4 //约束！有人帮我们实现 5 //abstract， 抽象方法，只有方法名字，没有方法的实现 6 public abstract void doSomething(); 7 ? 8 //1.抽象类中可以写普通的方法 9 //2.抽象方法必须写在抽象类中 10 //3.不能 new 一个抽象类，只能靠子类去实现它；约束！
1 // 类 可以实现接口 implements, 2 // 多继承，利用接口可以多继承 3 public class UserServiceImpl implements UserService,TimeService { 4 //重写接口里的全部方法，以实现接口里面的所有类 5 @Override 6 public void add(String name) { 7 ? 8 } 9 ? 10 @Override 11 public void delete(String name) { 12 ? 13 } 14 // interface 定义的关键词，接口都需要有实现类 15 public interface UserService { 16 //接口中的所有定义其实都是抽象的public 17 void add(String name); 18 void delete(String name); 19 void update(String name); 20 void query(String name); 21 ? 22 }
接口作用：
定义一些方法，让不同的人实现
public abstract
public static final 以上两句都是默认修饰符，不用写在代码中
接口不能被实例化，接口中没有构造方法
implement可以实现多个接口
必须要重写接口中的方法
1 //成员内部类 2 public class Outer { 3 ? 4 private int id = 10; 5 public void out(){ 6 System.out.println("这是外部类的方法"); 7 } 8 public class Inter{ 9 public void out(){ 10 System.out.println("这是内部类的方法"); 11 } 12 ? 13 //获得外部类的私有属性 14 public void getID(){ 15 System.out.println(id); 16 } 17 } 18 }
1 //main方法中调用 2 Outer outer = new Outer(); 3 //通过这个外部类来实例化内部类，outer.new Inter() 4 Outer.Inter inter = outer.new Inter(); 5 inter.getID();
类与对象
类是一个模板：抽象，对象是一个具体的实例
方法
定义、调用！
对象的引用
引用类型： 基本类型（8）
对象是通过引用来操作的：栈——>堆
属性：字段Field 成员变量
默认初始化：
数字：0 0.0
char：u000
boolean：false
引用： null
修饰符 属性类型 属性名 = 属性值
对象的创建和使用
必须使用new 关键词创建对象 ， 构造器 Person xiaoming = new Person（）
对象的属性 xiaoming.name
对象的方法 xiaoming.sleep（）
类：
静态的属性 ： 属性
原文：https://www.cnblogs.com/juvenileblogs/p/13509915.html