java面向对象高级一（共3集）

admin · 发表于前天 21:17

1，类的成分：构造器

2，实体类Javabean

关键字

4，static修饰成员变量

5，static修饰方法

6，静态方法的常见应用场景

7，静态方法，实例方法访问相关的几点注意事项

静态方法中可以直接访问静态成员，不可以直接访问实例成员。
实例方法中既可以直接访问静态成员，也可以直接访问实例成员。
实例方法中可以出现this关键字，静态方法中不可以出现this关键字的。

8，什么是继承？

9，什么是权限修饰符
就是是用来限制类中的成员（成员变量、成员方法、构造器）能够被访问的范围。

10，方法重写

当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。
重写小技巧：使用Override注解，他可以指定java编译器，检查我们方法重写的格式是否正确，代码可读性也会更好。

方法重写的其它注意事项
子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限（ public > protected > 缺省）。
重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
私有方法、静态方法不能被重写，如果重写会报错的。

方法重写是什么?
子类写了一个方法名称，形参列表与父类某个方法一样的方法去覆盖父类的该方法。
重写方法有哪些注意事项？
建议加上：@Override注解，可以校验重写是否正确，同时可读性好。
子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。
重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
私有方法、静态方法不能被重写。
方法重写有啥应用场景？
当子类觉得父类的方法不好用，或者不满足自己的需求时，就可以用方法重写。

11，子类构造器的特点

12，子类构造器调用父类构造器的场景应用场景

13，补充知识：this(…)调用兄弟构造器

14，什么是多态？

多态的好处

package com.jinhei.demo;
public class Test {
public static void main(String[] args) {
// 目标：认识多态的代码。
// 1、对象多态、行为多态。
Animal a1 = new Wolf();
a1.run(); // 方法：编译看左边，运行看右边
System.out.println(a1.name); // 成员变量：编译看左边，运行也看左边
Animal a2 = new Tortoise();
a2.run(); // 方法：编译看左边，运行看右边
System.out.println(a2.name); // 成员变量：编译看左边，运行也看左边
}
}

复制代码

运行结果：

package com.jinhei.demo;
public class Test {
public static void main(String[] args) {
// 目标：认识多态的代码。
// 1、多态的好处1: 右边对象是解耦合的。
Animal a1 = new Tortoise();
a1.run();
// a1.shrinkHead(); // 多态下的一个问题：多态下不能调用子类独有功能。
// 强制类型转换：可以解决多态下调用子类独有功能
Tortoise t1 = (Tortoise) a1;
t1.shrinkHead();
// 有继承关系就可以强制转换，编译阶段不会报错！
// 运行时可能会出现类型转换异常：ClassCastException
// Wolf w1 = (Wolf) a1;
System.out.println("=======================");
Wolf w = new Wolf();
go(w);
Tortoise t = new Tortoise();
go(t);
}
public static void go(Animal a){
System.out.println("开始。。。。。");
a.run();
// a1.shrinkHead(); // 报错，多态下不能调用子类独有功能。
// java建议强制转换前，应该判断对象的真实类型，再进行强制类型转换。
if(a instanceof Wolf){
Wolf w1 = (Wolf) a;
w1.eatSheep();
}else if(a instanceof Tortoise){
Tortoise t1 = (Tortoise) a;
t1.shrinkHead();
}
}
}

复制代码

多态下的类型转换问题

15，认识final

16，常量

17，枚举

枚举案例：

package com.jinhei.demo;
public class Constant {
public static final int UP = 0; // 上
public static final int DOWN = 1; // 下
public static final int LEFT = 2; // 左
public static final int RIGHT = 3; // 右
}

复制代码

package com.jinhei.demo;
public enum Direction {
UP, DOWN, LEFT, RIGHT;
}

复制代码

package com.jinhei.demo;
public class Test {
public static void main(String[] args) {
// 目标：掌握枚举类的应用场景：做信息的分类和标志。
// 需求：模拟上下左右移动图片。
// 第一种是常量做信息标志和分类: 但参数值不受约束。
move(Constant.UP);
// 第二种是枚举做信息标志和分类: 参数值受枚举类约束。
move2(Direction.DOWN);
}
public static void move2(Direction direction){
// 根据这个方向做移动：上下左右。
switch (direction){
case UP :
System.out.println("向上移动");
break;
case DOWN :
System.out.println("向下移动");
break;
case LEFT :
System.out.println("向左移动");
break;
case RIGHT :
System.out.println("向右移动");
break;
}
}
public static void move(int direction){
// 根据这个方向做移动：上下左右。
switch (direction){
case Constant.UP :
System.out.println("向上移动");
break;
case Constant.DOWN :
System.out.println("向下移动");
break;
case Constant.LEFT :
System.out.println("向左移动");
break;
case Constant.RIGHT :
System.out.println("向右移动");
break;
default:
System.out.println("输入有误");
}
}
}

复制代码

枚举类的特点

admin · 发表于昨天 19:54

抽象类

package com.jinhei.demo;
// 抽象类
public abstract class A {
private String name;
private int age;
public A() {
System.out.println("A的无参构造器");
}
public A(String name, int age) {
this.name = name;
this.age = age;
}
// 抽象方法：必须用abstract修饰，没有方法体，只有方法声明。
public abstract void show();
public void show1() {
System.out.println("show1方法");
}
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;
}
}

复制代码

package com.jinhei.demo;
// 一个类继承抽象类，必须重写完继承的全部抽象方法，否则这个类也必须定义成抽象类
public class B extends A{
@Override
public void show() {
System.out.println("B类重写show方法");
}
}

复制代码

package com.jinhei.demo;
public class Test {
public static void main(String[] args) {
// 目标：认识抽象类，抽象方法，搞清楚他们的特点。
// 抽象类的核心特点：有得有失（得到了抽象方法的能力，失去了创建对象的能力）
// 抽象类不能创建对象（重点）。
// A a = new A(); // 报错了
// 抽象类的使命就是被子类继承：就是为了生孩子。
B b = new B();
b.setName("张三");
b.setAge(18);
System.out.println(b.getName() + "---" + b.getAge());
b.show();
b.show1();
}
}

复制代码

使用抽象类的好处

模板方法设计模式

接口的概述

public interface 接口名
// 成员变量（常量）
// 成员方法（抽象方法）
}

接口的好处

弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大。
让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现（更利于程序的解耦合）。

接口新增的三种方法

1、JDK8开始，接口中新增了哪些方法?
默认方法：使用default修饰，使用实现类的对象调用。
静态方法：static修饰，必须用当前接口名调用
私有方法：private修饰，jdk9开始才有的，只能在接口内部被调用。
他们都会默认被public修饰。
2、JDK8开始，接口中为啥要新增这些方法?
增强了接口的能力，更便于项目的扩展和维护。

接口的注意事项

1、接口与接口可以多继承：一个接口可以同时继承多个接口[重点]。
2、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承，也不支持多实现。
4、一个类继承了父类，又同时实现了接口，如果父类中和接口中有同名的默认方法，实现类会优先用父类的。
5、一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

java面向对象高级一（共3集）

相关帖子