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
package com.oop.demo02;
// 封装 保护属性 对外只暴露想暴露的方法
// 低耦合 高内聚
// 保护数据
public class Student {
private
String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
// 封装
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;
}
}

1
2
3
4
5
6
7
8
9
10
package com.oop.demo02;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.setName("大鹏");
student.setAge(6);
System.out.println(student.getName()+"今年"+student.getAge()+"岁"); // 大鹏今年6岁
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.oop.demo03;
// 继承 子类继承父类
类与类之间的关系
关键词：extends
// 子类：派生类
父类：基类
// 子类继承父类 拥有父类的所有方法以及属性
private除外
// Java只能是单继承
即 一个爸爸多个儿子
// 重点：super 只能出现在子类中。相当于父类中this，可以获取父类的属性或者方法
// Java中 所有的类都间接或直接继承Object类
public class Person {
public Person(){
System.out.println("父类无参构造");
}
public int money = 10000;
public void method1(){
System.out.println("父类的方法");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.oop.demo03;
public class Student extends Person{
public Student(){
// 子类调用父类无参构造 只能写第一层
super();// 父类无参构造
System.out.println("子类无参构造"); // 子类无参构造
}
public void method1(){
// 子类使用super调用父类的属性
System.out.println("子类使用super调用父类的属性"+ super.money); // 子类使用super调用父类的属性10000
// 子类使用super调用父类的方法
super.method1(); // 父类的方法
}
}

1
2
3
4
5
6
7
8
9
10
11
package com.oop.demo03;
public class A {
public static void test(){
System.out.println("打印A");
}
public
void test1(){
System.out.println("打印A");
}
}

1
2
3
4
5
6
7
8
9
10
11
package com.oop.demo03;
public class B extends A{
public static void test(){
System.out.println("打印B");
}
public
void test1(){
System.out.println("打印B");
}
}

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
package com.oop.demo03;
public class Application {
public static void main(String[] args) {
method3();
Application application = new Application();
application.method2();
}
// 继承的实现方法
private void method1(){
Student student = new Student();
// 实例化对象调用父类的属性
System.out.println("实例化对象调用父类的属性"+student.money); // 实例化对象调用父类的属性10000
// 实例化对象调用子类的方法
student.method1();
// 父类无参构造
// 子类无参构造
// 实例化对象调用父类的属性10000
// 子类使用super调用父类的属性10000
// 父类的方法
}
// 重写
// 子类重写父类
// 方法名称相同
参数列表相同 修饰符范围可扩大
异常范围被缩小
// 非静态方法与后面有关
private
void method2(){
A a = new A(); // 打印A
a.test1();
B b = new B(); // 打印B
b.test1();
}
// 静态方法 至于左侧有关
private static
void method3(){
A a1 = new B(); // 打印A
a1.test();
B b1 = new B(); // 打印B
b1.test();
}
}

1
2
3
4
5
6
7
package com.oop.demo04;
public class A {
public void eat(){
System.out.println("父亲吃");
}
}

1
2
3
4
5
6
7
8
package com.oop.demo04;
public class B extends
A {
public void eat(){
System.out.println("儿子吃");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.oop.demo04;
// 多态
// 同一方法可以根据发送对象的不同而采用多种不同的行为方式
// 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多====》类名 别名 = new 类名，实例化左边为引用类型 右边为实际类型
// 存在条件
继承关系
子类重写父类方法
父类引用指向子类对象 只有方法多态
public class Application {
public static void main(String[] args) {
// 多态开始 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
B b = new B();
A a = new B();
Object o = new B();
a.eat(); // 儿子吃
b.eat(); // 儿子吃
//
o.eat(); 无方法
}
}