Day7-笔记（OOP、封装、继承、多态、static、instanceof、abstract）
面向对象编程---OOP
面向对象编程（objcet-oriented programming）oop
面向对象编程的本质就是：以类的方式组织代码，以对象的组织封装数据。
三大特性：封装、继承、多态
构造器详解
构造器：
1. 和类名相同
2. 没有返回值
作用：
1. new本质就是在调用构造方法
2. 初始化对象的值
注意点：
如果定义了一个有参构造之后，如果想使用无参构造，必须要重新定义一个无参构造。
快捷键：Alt+Insert 插入方法自动生成get和set 无参有参构造方法
创建内存对象分析
栈：存放变量名
堆：存放对象
小结
-
类与对象
类是一个模板：抽象，对象是类的实例
-
方法
定义、调用！！
-
对象的引用
引用类型：
基本类型（8）byte short int long float double char boolean
-
属性 字段field 成员变量
默认初始化：
数字：0 0.0
char: u0000
引用：null
修饰符 属性类型 属性名 =属性值！
-
对象的创建和使用
必须使用new关键字创建对象，构造器 Person xiaoli = new Person();
-
对象的属性 xiaoli.name
-
对象的方法 xiaoli.eat()
-
-
类
静态的属性 属性
动态的行为 方法
封装
封装：该露的露，该藏的藏。
- 高内聚，低耦合
封装---数据的隐藏
通常，应禁止直接访问一个对象中数据的实际显示，应通过操作接口来访问，这称之为信息隐藏。
属性私有，get/set访问与操作。
继承
子类继承父类的所有方法
public class Person {
//JDK7的新特性
protected int money = 10_0000_0000;
public Person() {
System.out.println("Person的无参构造方法");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
public class Student extends Person {
private String name;
private int age;
private int studyID;
private char sex;
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 int getStudyID() {
return studyID;
}
public void setStudyID(int studyID) {
this.studyID = studyID;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public void print(Student student) {
System.out.println("Name:" + student.getName());
System.out.println("Sex:" + student.getSex());
System.out.println("Age::" + student.getAge());
System.out.println("StudyID:" + student.getStudyID());
}
public void sleep() {
System.out.println(this.name + "在睡觉");
}
public void study() {
System.out.println(this.name + "在学习");
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//alt+insert
public Student() {
// this(); //this 也是只能放在第一行，与super()只能二选一
//隐藏代码：super()，调用父类的构造器，必须放在方法的第一行，否则会报错
super();
System.out.println("Student的无参构造方法");
}
}
super注意点：
1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法
VS this:
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法：
this（）；本类的构造
super（）；父类的构造
多态
多态：同一方法可以根据发送对象的不同而采用多种不同的行为方式。
-
多态是方法的多态，属性没有多态
-
父类和子类，有联系 类型转换异常！ ClassCastException！
-
存在条件：有继承关系，方法需要重写，父类引用指向子类对象
Father f1 = new Son();
以下方法不能被重写：
-
static方法，属于类，它不属于实例
-
final常量
-
private方法
-
// 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）
// new Student();
// new Person();
//可以指向的引用类型就不确定了：父类的引用指向子类
//Student 能调用的方法都是自己的或者是继承的父类的
Student s1 = new Student();
//父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
s1.run();
s2.run();
((Student) s2).study();//子类重写了父类的方法，执行子类的方法
((Student) s2).sleep();
s3.toString();
instanceof
（类型转换） 引用类型
// System.out.println(X instanceof Y); //是否存在父子关系，存在则编译通过！！
// object > String
// object > Person > Student
// object > Person > Teacher
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("==============================================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //false
// System.out.println(person instanceof String); // 编译报错
System.out.println("==============================================");
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
// System.out.println(student instanceof Teacher); // 编译报错
// System.out.println(student instanceof String); // 编译报错
System.out.println("==============================================");
}
//类型之剑的转换：父 子
//高 低
Person obj = new Student();
//将student这个对象转换为Student类型。就可以使用Student类型的方法了。
((Student) obj).go();
//子类转换为父类，可能会丢失自己本来的一些方法!!!
Student student1 = new Student();
student1.go();
Person person = student1;
person.run
static详解
public class Person {
//2--第二顺序 用于赋初值
{
//代码块 （匿名代码块）
System.out.println("匿名代码块");
}
//1--最先执行 只执行一次
static {
//静态代码块
System.out.println("静态代码块");
}
//3--第三顺序
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("------------------");
Person person1 = new Person();
}
}
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
抽象类abstract
//abstra 抽象类 extends：单继承
public abstract class Action {
//约束 有人帮我们实现~
//abstract 抽象方法，只有方法名字，没有方法的实现。
public abstract void doSomething();
//1. 抽象类不能new，只能靠子类去实现它：约束！
//2. 抽象类中可以写普通的方法
//3. 抽象方法必须在抽象类中
public Action() {
System.out.println("aaaaaaaaa");
}
}
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非这个子类也是抽象类。
public class A extends Action {
@Override
public void doSomething() {
System.out.println("dosomething");
}
}
抽象类也有构造器！
存在的意义：程序的可扩展性！
本文来自博客园，作者：xiaolifc，转载请注明原文链接：https://www.cnblogs.com/xiaolibiji/p/14992638.html
浙公网安备 33010602011771号