面向对象
一、概念
在现实世界生活：
类：抽象的概念，把具有相同特征和操作的事物归为一类
先有实体，再有类的概念
在我们代码的世界里：
类：抽象的概念，把具有相同属性和方法的对象归为一列
编写顺序：先有类，再创建对象
类的作用：类相当于一个模板，刻画出具有相同属性和方法的对象
二、类
- 类中只有属性和方法
- 属性也叫做全局变量，属性分为成员变量和静态变量
- 方法分为成员方法和静态方法
public class 类名{
//属性也叫做全局变量，分为成员变量和静态变量
//成员变量
数据类型 变量名;
//静态变量
static 数据类型 变量名;
//方法分为成员方法和静态方法
//成员方法
访问修饰符 返回值类型 方法名([参数]){}
//静态方法
访问修饰符 static 返回值类型 方法名([参数]){}
}
三、对象
创建对象的语法：类名 对象名 = new 类名();
new 构造方法; 属于对象，就在堆内存中开辟空间
类名 对象名 ：对象名属于引用，存的是对象在堆内存中的地址
操作对象：
- 设置成员属性
- 获取成员属性
- 调用成员方法
四、成员属性/成员变量
语法结构：数据类型 变量名;
编写的位置：类里，方法的外面
成员变量 vs 局部变量
成员变量：类里，方法的外面的变量，并且系统会赋默认值，作用在整个类中
局部变量：方法内的变量，系统不会赋默认值，作用在方法中
五、成员方法
语法结构：访问修饰符 返回值类型 方法名([参数]){}
编写的位置：类里
成员方法 vs 静态方法
成员方法：属于对象的方法，必须使用对象调用
静态方法：属于类的方法，使用类名调用
六、构造方法
含义：和new一起是创建对象的功能
特点：
- 与类名相同的方法
- 没有返回项
作用：
- 和new在一起是创建对象
- 初始化属性
注意：
- 当类中没有写构造方法时，系统会默认添加无参构造（无参数的构造方法）
- 构造方法可以重载的
有参构造好处：创建对象时，把数据赋值给该对象
public class Person{ //注意：这种不是构造方法，是成员方法 public void Person(){} }代码理解：
public class Person { String name; char sex; int age; public Person(){} public Person(String name,char sex,int age){ this.name = name; this.sex = sex; this.age = age; } public void eat() { System.out.println(this.name + "吃饭饭"); } public void sleep() { System.out.println(this.name + "睡觉觉"); } }测试类
public class Test { public static void main(String[] args) { Person p = new Person("榮十一", '男', 22); p.eat(); } }
七、private - 私有化
含义：私有化
作用：
- 修饰属性：私有化属性，不能让外界使用
- 修饰方法：私有化方法，不能让外界使用
应用场景：不让外界访问的属性和方法就使用private修饰
代码块理解：
类
public class A { private String str; private void method01(){ this.str = "aaa"; System.out.println(this.str); } public void method02(){ this.method01(); } }测试类:
public class Test01 { public static void main(String[] args) { A a = new A(); a.method02(); } }
八封装
步骤：
- 私有化属性
- 添加get（获取）/set（设置）方法
好处：
- 外界不可以直接操作属性，必须通过get、set方法操作，可以在get、set方法中做格外的功能
- 保护属性安全，让属性不能在外界直接调用
- 添加get/set方法后，可以在获取方法中（get（））和设置方法中（set（））做额外的功能
代码理解：
类
import java.time.LocalDateTime; public class User { private String username; private String password; private String name; private double money; public User() { } public User(String username, String password, String name, double money) { this.username = username; this.password = password; this.name = name; this.money = money; } //获取本对象的money属性 public double getMoney(){ //额外的功能 System.out.println(LocalDateTime.now() + "获取了money属性：" + money); return this.money; } //设置本对象的money属性 public void setMoney(double money){ //额外的功能 System.out.println(LocalDateTime.now() + "设置了money属性：" + money); this.money = money; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getName() { return name; } public void setName(String name) { this.name = name; } }测试类
public class Test01 { public static void main(String[] args) { /** * 知识点：封装 * 需求：模拟银行的用户类 * * 总结：编写类的流程 * 1.属性 * 2.私有化属性 * 3.无参、有参构造 * 4.get/set方法 */ User user = new User("1445584980", "123123", "千锋彭于晏", 3500); //不要直接操作属性，因为这个行为只能操作属性值，不能做其他功能 // user.money = user.money-200; // System.out.println(user.money); //取钱：1.存凭证 2.修改金额 user.setMoney(user.getMoney()-200); System.out.println(user.getMoney()); } }
九、this - 本对象
含义：代表本对象，this出现方法里，表示调用该方法的对象
作用：
- this.属性：调用本对象的成员变量
- this.方法：调用本对象的成员方法
- this()：调用本对象的构造方法（在一个构造方法中的第一句调用另外一个构造方法）
代码块的理解
类：
public class Person { private String name; private char sex; private int age; public Person() { //调用本类的构造方法 this("默认姓名", '男', 18); } public Person(String name, char sex) { this.name = name; this.sex = sex; } public Person(String name, char sex, int age) { this.name = name; this.sex = sex; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void eat(){ //this.name：调用本对象的成员变量 System.out.println(this.name + "吃饭饭"); //利用本对象调用成员方法 this.sleep(); } public void sleep(){ System.out.println(this.name + "睡觉觉"); } }测试类：
public class Test01 { public static void main(String[] args) { Person p = new Person(); System.out.println(p.getName()); p.eat(); } }
十、分包
基本作用：防止了类的重名问题
项目作用：项目中有众多的类，把相同功能的类放在同一个包中，方便管理
工具类：com.dream.util/tool
实体类：com.dream.vo/bean/entity
数据库类：com.dream.dao/mapper
十一、static - 静态的
作用：
修饰属性
类加载到方法区时，JVM会扫描该类的所有属性
并把静态属性加载到静态区中，静态属性属于类属性，
该类所有的对象都共享该属性
静态属性直到项目结束时才会被回收 注意：静态属性使用类名调用
修饰方法
属于类方法，直接用类名调用
应用场景：工具类
静态代码块
静态代码块是类加载到方法区时才会被调用，该代码块只能初始化静态变量
代码块是创建对象时优先于构造方法调用，该代码块可以初始化成员变量和静态变量
构造方法是创建对象时调用，该方法可以初始化成员变量和静态变量
静态变量的生命周期：
字节码文件加载到方法区时，系统会扫描该类所有的属性，并把静态变量存放到静态区项目结束时，静态变量才会被回收
成员变量 vs 静态变量
成员变量：属于对象的变量，每个对象独享一份
静态变量：属于类的变量，每个对象都共享一份
代码块的理解：
类：
public class A { //成员变量 String str1; //静态变量 static String str2; }测试类：
public class Test01 { public static void main(String[] args) { A a1=new A(); A a2=new A(); a1.str1="aaa"; a2.str1="bbb"; System.out.println(a1.str1); System.out.println(a2.str1); A.str2="ccc"; A.str2="ddd"; System.out.println(a1.str2); System.out.println(a2.str2); } }
十二、类加载机制面试题
一：
public class Test01 { public static void main(String[] args) { /** * 知识点：类加载机制面试题 */ System.out.println("A value1:" + A.value1);//1 System.out.println("A value2:" + A.value2);//0 } } class A{ /** * 准备阶段1： * A a; * int value1; * int value2; * * 准备阶段2： * A a = null; * int value1 = 0; * int value2 = 0; * * 初始化阶段： * A a = new A(); * int value1 = 1; * int value2 = 0; */ private static A a = new A(); public static int value1; public static int value2 = 0; private A(){ value1++; value2++; } }二：
public class Test01 { public static void main(String[] args) { /** * 知识点：类加载机制面试题 */ System.out.println("B value1:" + B.value1);//1 System.out.println("B value2:" + B.value2);//1 } } class B{ /** * 准备阶段1： * int value1; * int value2; * B b; * * 准备阶段2： * int value1 = 0; * int value2 = 0; * B b = null; * * 初始化阶段： * int value1 = 1; * int value2 = 1; * B b = new B(); */ public static int value1; public static int value2 = 0; private static B b = new B(); private B(){ value1++; value2++; } }
十三、继承
使用场景：
多个类似的类，有相同的属性和方法，就可以把相同属性和方法抽取到父类
好处：减少了代码的冗余
深入继承：
创建子类对象，会不会调用父类构造方法？
会
创建子类对象，会不会创建父类对象？
不会
创建子类对象，为什么会调用父类构造方法？
目的是将父类的属性存放在子类对象中创建子类对象，先调用父类构造方法还是子类构造方法？
先调用子类构造方法创建子类对象，先完成父类构造方法还是子类构造方法？
先完成父类构造方法子类可以继承父类私有化的属性和方法吗？
可以，但是只能间接调用
十四、super - 父类
含义：代表父类
作用 在子类中：
- super.属性：调用父类非私有化的成员变量
- super.方法：调用父类非私有化的成员方法
- super()：调用父类非私有化的构造方法
十五、重写方法
含义： 重写也叫做复写，将父类中方法在子类中重新编写一遍
应用场景：父类方法不满足子类需求时，子类就可以重复父类的方法
条件：
1. 在子类中重写父类的方法 2. 返回值、方法名和参数列表必须和父类重写的方法一致 3. 访问修饰符不能比父类重写的方法更严格
十六、访问修饰符
含义：修饰类、方法、属性，定义使用的范围
学习：做实验
访问修饰符 本类 本包 其他包子类 其他包 private OK 默认的 OK OK protected OK OK OK public Ok OK OK Ok
十七、Object
含义：基类也叫做超类，Object是所有类的祖先类
**注意：**如果一个类没有明确继承的父类，默认继承Object
equals：比较两个对象内存地址是否相同
hashCode：获取对象的hash值
getClass：获取类的字节码文件对象
toString：获取对象的字符串表示
标杆作用：
Object作为所有类的父类，定义了几个方法，方便子类去重写
equals的标杆作用：
比较两个对象是否相同，不同的对象比较规则不一样，所以子类重写即可
toString的标杆作用：
每个子类都有不同的属性，重写toString直接打印该对象中所有的属性，方便观察数据
十八、final的使用
含义：最终
作用：
修饰类：该类不能被继承
修饰方法：该方法不能被重写
修饰变量：变成常量，不能重新赋值
常量的命名规则：全大写，单词之间用下划线隔开
常量的声明周期：存在常量池中，直到项目结束才会被销毁
十九、抽象类及抽象方法
//抽象类
public abstract class 类名{
//抽象方法
public abstract void method();
}
抽象方法交给非抽象的子类去实现(重写)
应用场景：
当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，交给非抽象的子类去实现
面试题：
抽象类不能有构造方法？
抽象类可以有构造方法
抽象类中只能有抽象方法？
抽象类中有非抽象方法（成员方法和静态方法）
抽象类中不可以没有抽象方法？
抽象类中可以没有抽象方法，但是毫无意义
如果父类是抽象类，则子类必须实现父类的抽象方法？
不一定，子类如果是抽象类，可以不实现父类的抽象方法
可以使用new关键字来创建抽象类对象？
不可以，创建的是匿名内部类的对象
二十、接口
含义：特殊的抽象类
注意：
- JDK1.7时，接口中只能有静态常量和抽象方法JDK
- 1.8开始，接口中有静态常量和抽象方法和默认方法
应用场景：接口更像一个规范
抽象类 vs 接口
抽象类：成员变量、静态变量、静态常量、成员方法、静态方法
接口：静态常量、静态方法、默认方法(JDK1.8)
面试题：
一个类可以实现多个接口？可以
一个接口可以实现多个接口？不可以，接口与接口的关系是多继承
接口里面的方法不一定都是抽象的？JDK1.7时接口里只能有抽象方法，JDK1.8时接口可以有抽象方法和默认方法
接口解决了类的单继承问题？是的，因为类与类是单继承，类与接口是多实现
一个类是否可以继承一个类并同时实现多个接口？可以
接口可以new对象？接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象
类 - 接口的关系：
- 类 - 类：单继承
- 类 - 接口：多实现
- 接口 - 接口：多继承
458
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
