面向对象
- 面向对象
- 一、概念
- 二、类
- 三、对象
- 四、成员属性/成员变量
- 五、成员方法
- 六、构造方法
- 七、private - 私有化
- 八封装
- 九、this - 本对象
- 十、分包
- 十一、static - 静态的
- 十二、类加载机制面试题
- 十三、继承
- 十四、super - 父类
- 十五、重写方法
- 十六、访问修饰符
- 十七、Object
- 十八、final的使用
- 十九、抽象类及抽象方法
- 二十、接口
一、概念
在现实世界生活：
类：抽象的概念，把具有相同特征和操作的事物归为一类
先有实体，再有类的概念
在我们代码的世界里：
类：抽象的概念，把具有相同属性和方法的对象归为一列
编写顺序：先有类，再创建对象
类的作用：类相当于一个模板，刻画出具有相同属性和方法的对象
二、类
- 类中只有属性和方法
- 属性也叫做全局变量，属性分为成员变量和静态变量
- 方法分为成员方法和静态方法
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class 类名{ //属性也叫做全局变量，分为成员变量和静态变量 //成员变量 数据类型 变量名; //静态变量 static 数据类型 变量名; //方法分为成员方法和静态方法 //成员方法 访问修饰符 返回值类型 方法名([参数]){} //静态方法 访问修饰符 static 返回值类型 方法名([参数]){} }
三、对象
创建对象的语法：类名 对象名 = new 类名();
new 构造方法; 属于对象，就在堆内存中开辟空间
类名 对象名 ：对象名属于引用，存的是对象在堆内存中的地址
操作对象：
- 设置成员属性
- 获取成员属性
- 调用成员方法
四、成员属性/成员变量
语法结构：数据类型 变量名;
编写的位置：类里，方法的外面
成员变量 vs 局部变量
成员变量：类里，方法的外面的变量，并且系统会赋默认值，作用在整个类中
局部变量：方法内的变量，系统不会赋默认值，作用在方法中
五、成员方法
语法结构：访问修饰符 返回值类型 方法名([参数]){}
编写的位置：类里
成员方法 vs 静态方法
成员方法：属于对象的方法，必须使用对象调用
静态方法：属于类的方法，使用类名调用
六、构造方法
在这里插入图片描述
含义：和new一起是创建对象的功能
特点：
- 与类名相同的方法
- 没有返回项
作用：
- 和new在一起是创建对象
- 初始化属性
注意：
- 当类中没有写构造方法时，系统会默认添加无参构造（无参数的构造方法）
- 构造方法可以重载的
有参构造好处：创建对象时，把数据赋值给该对象
复制代码1
2
3
4
5public class Person{ //注意：这种不是构造方法，是成员方法 public void Person(){} }代码理解：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25public 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 + "睡觉觉"); } }测试类
复制代码1
2
3
4
5
6
7
8
9
10
11public class Test { public static void main(String[] args) { Person p = new Person("榮十一", '男', 22); p.eat(); } }
七、private - 私有化
含义：私有化
作用：
- 修饰属性：私有化属性，不能让外界使用
- 修饰方法：私有化方法，不能让外界使用
应用场景：不让外界访问的属性和方法就使用private修饰
代码块理解：
类
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class A { private String str; private void method01(){ this.str = "aaa"; System.out.println(this.str); } public void method02(){ this.method01(); } }测试类:
复制代码1
2
3
4
5
6
7
8
9
10public class Test01 { public static void main(String[] args) { A a = new A(); a.method02(); } }
八封装
步骤：
- 私有化属性
- 添加get（获取）/set（设置）方法
好处：
- 外界不可以直接操作属性，必须通过get、set方法操作，可以在get、set方法中做格外的功能
- 保护属性安全，让属性不能在外界直接调用
- 添加get/set方法后，可以在获取方法中（get（））和设置方法中（set（））做额外的功能
代码理解：
类
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61import 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; } }测试类
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26public 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()：调用本对象的构造方法（在一个构造方法中的第一句调用另外一个构造方法）
代码块的理解
类：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59public 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 + "睡觉觉"); } }测试类：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14public 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会扫描该类的所有属性
并把静态属性加载到静态区中，静态属性属于类属性，
该类所有的对象都共享该属性
静态属性直到项目结束时才会被回收 注意：静态属性使用类名调用
修饰方法
属于类方法，直接用类名调用
应用场景：工具类
静态代码块
静态代码块是类加载到方法区时才会被调用，该代码块只能初始化静态变量
代码块是创建对象时优先于构造方法调用，该代码块可以初始化成员变量和静态变量
构造方法是创建对象时调用，该方法可以初始化成员变量和静态变量
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31public class A { String str1; static String str2; //静态代码块：类加载到方法区时调用 //可以初始化静态变量 static{ str2 = "yyy";//A.str2 System.out.println("A的静态代码块"); } //代码块：创建对象时优先于构造方法调用 //可以初始化静态变量、成员变量 { str1 = "xxx";//this.str1 str2 = "yyy";//A.str2 System.out.println("A的代码块"); } //构造方法：创建对象时调用 //可以初始化静态变量、成员变量 public A() { str1 = "xxx";//this.str1 str2 = "yyy";//A.str2 System.out.println("A的构造方法"); } }复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class Test01 { public static void main(String[] args) { /** * 知识点：静态代码块 - 了解 */ A a1 = new A(); A a2 = new A(); } }静态变量的生命周期：
字节码文件加载到方法区时，系统会扫描该类所有的属性，并把静态变量存放到静态区项目结束时，静态变量才会被回收
成员变量 vs 静态变量
成员变量：属于对象的变量，每个对象独享一份
静态变量：属于类的变量，每个对象都共享一份
代码块的理解：
类：
复制代码1
2
3
4
5
6
7
8
9public class A { //成员变量 String str1; //静态变量 static String str2; }测试类：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public 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); } }
十二、类加载机制面试题
一：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43public 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++; } }二：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39public 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++; } }
十三、继承
使用场景：
多个类似的类，有相同的属性和方法，就可以把相同属性和方法抽取到父类
好处：减少了代码的冗余
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class Person { String name; char sex; int age; public void eat(){ System.out.println("吃饭饭"); } public void sleep(){ System.out.println("睡觉觉"); } }复制代码1
2
3
4
5
6
7
8
9public class Chinese extends Person{ String chineseId; public void playTaiJi(){ System.out.println("打太极"); } }复制代码1
2
3
4
5
6
7
8
9public class Japanese extends Person{ String yearNumber; public void playVideo(){ System.out.println("拍电影"); } }复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57public static void main(String[] args) { /** * 知识点：继承 * 含义：子类继承父类的属性和方法 * 好处：减少代码冗余 * 应用场景：多个类中有相同的属性和方法，就抽取出放在父类里 * * 需求：编写中国人、日本日 * 分析： * 中国人 继承 人类： * 属性：中国人的身份证 * 方法：打太极 * 日本人 继承 人类： * 属性：年号 * 方法：拍电影 * 人类： * 属性：姓名、性别、年龄 * 方法：吃饭饭、睡觉觉 */ Chinese c = new Chinese(); //操作父类属性 c.name = "榮十一"; c.sex = '男'; c.age = 21; System.out.println(c.name); System.out.println(c.sex); System.out.println(c.age); //操作子类属性 c.chineseId = "1234567890"; System.out.println(c.chineseId); //调用父类方法 c.eat(); c.sleep(); //调用子类方法 c.playTaiJi(); Japanese j = new Japanese(); //操作父类属性 j.name = "美田桜奈汾"; j.sex = '女'; j.age = 18; System.out.println(j.name); System.out.println(j.sex); System.out.println(j.age); //操作子类属性 j.yearNumber = "令和"; System.out.println(j.yearNumber); //调用父类方法 j.eat(); j.sleep(); //调用子类方法 j.playVideo(); } }
深入继承：
创建子类对象，会不会调用父类构造方法？
会
创建子类对象，会不会创建父类对象？
不会
创建子类对象，为什么会调用父类构造方法？
目的是在子类对象中开辟空间用于存放父类的属性创建子类对象，先调用父类构造方法还是子类构造方法？
先调用子类构造方法创建子类对象，先完成父类构造方法还是子类构造方法？
先完成父类构造方法子类可以继承父类私有化的属性和方法吗？
可以继承，但是不可以直接调用，但是可以在父类中设置公有的方法，在公有的方法中调用私有的属性和方法，这叫做间接调用
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22public class A { String aAtrr; public A() { System.out.println("父类的构造方法"); } //父类私有化属性 private String a = "xxx"; //父类私有化方法 private void aMethod01(){ System.out.println("父类私有化方法"); } public void aMethod02(){ System.out.println(a); aMethod01(); } }复制代码1
2
3
4
5
6
7
8
9
10
11
12public class B extends A{ String bAtrr; public B() { //super();//调用父类无参构造，默认实现 System.out.println("子类的构造方法"); } }复制代码1
2
3
4
5
6
7
8
9public class Test01{ public static void main(String[] args){ B b = new B(); b.aMethod02(); } }
十四、super - 父类
含义：代表父类
作用 在子类中：
- super.属性：调用父类非私有化的成员变量
- super.方法：调用父类非私有化的成员方法
- super()：调用父类非私有化的构造方法
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13public class A { String str; public A() { } public void aMethod(){ System.out.println("A类的方法"); } }复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class B extends A{ public B() { //调用父类的非私有化构造方法 super(); } public void method(){ //调用父类的非私有化属性 super.str = "xxx"; //调用父类的非私有化方法 super.aMethod(); } }
十五、重写方法
含义： 重写也叫做复写，将父类中方法在子类中重新编写一遍
应用场景：父类方法不满足子类需求时，子类就可以重复父类的方法
条件：
复制代码1
2
3
41. 在子类中重写父类的方法 2. 返回值、方法名和参数列表必须和父类重写的方法一致 3. 访问修饰符不能比父类重写的方法更严格复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53public class Test01 { public static void main(String[] args) { /** * 知识点：重写/复写 * 应用场景：父类方法不满足子类需求时，可以在子类中重写 * 条件： * 1.重写的位置是在子类中 * 2.返回值、方法名、参数列表必须和重写父类的方法一致 * 3.访问修饰符不能比父类更严格 * * 需求：编写中国人、日本日 * 分析： * 中国人 继承 人类： * 属性：中国人的身份证 * 方法：打太极 * 日本人 继承 人类： * 属性：年号 * 方法：拍电影 * 人类： * 属性：姓名、性别、年龄 * 方法：吃饭饭、睡觉觉 */ Chinese c = new Chinese("榮十一", '男', 21, "1234567890"); System.out.println(c.getName()); System.out.println(c.getSex()); System.out.println(c.getAge()); System.out.println(c.getChineseId()); //调用父类方法 c.sleep(); //调用子类方法 c.playTaiJi(); //调用子类重写父类的方法 c.eat(); System.out.println("------------"); Japanese j = new Japanese("美田桜奈汾", '女', 18, "令和"); System.out.println(j.getName()); System.out.println(j.getSex()); System.out.println(j.getAge()); System.out.println(j.getYearNumber()); //调用父类方法 j.sleep(); //调用子类方法 j.playVideo(); //调用子类重写父类的方法 j.eat(); } }复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31public class Chinese extends Person{ private String chineseId; public Chinese() { } public Chinese(String name, char sex, int age, String chineseId) { super(name, sex, age); this.chineseId = chineseId; } public String getChineseId() { return chineseId; } public void setChineseId(String chineseId) { this.chineseId = chineseId; } public void playTaiJi(){ System.out.println(super.getName() + "打太极"); } @Override public void eat(){ System.out.println(super.getName() + "吃山珍海味"); } }复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32public class Japanese extends Person{ private String yearNumber; public Japanese() { } public Japanese(String name, char sex, int age, String yearNumber) { super(name, sex, age); this.yearNumber = yearNumber; } public String getYearNumber() { return yearNumber; } public void setYearNumber(String yearNumber) { this.yearNumber = yearNumber; } public void playVideo(){ System.out.println(super.getName() + "拍电影"); } //@Override - 注解：既解释给程序员也解释给程序，告诉程序这个方法是重写父类的方法 @Override public void eat() { System.out.println(super.getName() + "吃美汾寿司"); } }复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50public class Person { private String name; private char sex; private int age; public Person() { } 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(){ System.out.println(this.name + "吃饭饭"); } public void sleep(){ System.out.println(this.name + "睡觉觉"); } }
十六、访问修饰符
含义：修饰类、方法、属性，定义使用的范围
学习：做实验
访问修饰符 本类 本包 其他包子类 其他包 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的使用
含义：最终
作用：
修饰类：该类不能被继承
修饰方法：该方法不能被重写
修饰变量：变成常量，不能重新赋值
常量的命名规则：全大写，单词之间用下划线隔开
常量的声明周期：存在常量池中，直到项目结束才会被销毁
十九、抽象类及抽象方法
复制代码
1
2
3
4
5
6//抽象类 public abstract class 类名{ //抽象方法 public abstract void method(); }
抽象方法交给非抽象的子类去实现(重写)
应用场景：
当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，交给非抽象的子类去实现
面试题：
抽象类不能有构造方法？
抽象类可以有构造方法
抽象类中只能有抽象方法？
抽象类中有非抽象方法（成员方法和静态方法）
抽象类中不可以没有抽象方法？
抽象类中可以没有抽象方法，但是毫无意义
如果父类是抽象类，则子类必须实现父类的抽象方法？
不一定，子类如果是抽象类，可以不实现父类的抽象方法
可以使用new关键字来创建抽象类对象？
不可以，创建的是匿名内部类的对象
二十、接口
含义：特殊的抽象类
注意：
- JDK1.7时，接口中只能有静态常量和抽象方法JDK
- 1.8开始，接口中有静态常量和抽象方法和默认方法
应用场景：接口更像一个规范
抽象类 vs 接口
抽象类：成员变量、静态变量、静态常量、成员方法、静态方法
接口：静态常量、静态方法、默认方法(JDK1.8)
面试题：
一个类可以实现多个接口？可以
一个接口可以实现多个接口？不可以，接口与接口的关系是多继承
接口里面的方法不一定都是抽象的？JDK1.7时接口里只能有抽象方法，JDK1.8时接口可以有抽象方法和默认方法
接口解决了类的单继承问题？是的，因为类与类是单继承，类与接口是多实现
一个类是否可以继承一个类并同时实现多个接口？可以
接口可以new对象？接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象
类 - 接口的关系：
- 类 - 类：单继承
- 类 - 接口：多实现
- 接口 - 接口：多继承
最后
以上就是聪慧马里奥最近收集整理的关于JavaSE---------基础知识点08（面向对象（中）)面向对象的全部内容，更多相关JavaSE---------基础知识点08（面向对象（中）)面向对象内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复