1.final
1.1是什么
final是个修饰符,表示最终的,不可更改的
1.2能做什么
1.final修饰的类不能被继承
2.final修饰的成员方法不能被覆写
3.final修饰的变量,不能二次赋值,没有默认值,必须显式赋值
4.一般把final修饰的静态变量叫做常量,也就是 public static final 数据类型 变量名 = 值;
1.3怎么用
常量名建议全部大写
final static public int ID = 1;
1.4修饰引用类型
//先给出一个Customer类
class Customer {
String name;
int age;
public Customer(String name, int age) {
super();
this.name = name;
this.age = age;
}
2.多态
2.1是什么
父类引用指向子类对象
父类引用:用父类声明的引用类型变量
指向:通过内存地址可以找到哪个对象
子类对象: new 子类创建的堆内存对象
2.2相关知识
软件设计六大原则:
1.单一职责原则:功能单一,只拥抱一种变化
2.里式替换原则:能使用父类的情况下,一定可以使用子类
3.依赖倒置原则:细节应该依赖抽象,而抽象不应该依赖细节
4.接口隔离原则
5.迪米特法则:最少知识原则,和其他类或对象,尽可能有更少的了解
6.开闭原则:对修改关闭,对扩展开放
2.3优点
优点:同一操作,作用于不同对象,可以有不同的解释,产生不同的结果,这就是多态性。当一件事会有很多种不同实现方式的时候,我们选择依赖高层来拥抱多种变化,本质还是降低类和细节之间的耦合度
2.4缺点
缺点:丢失子类特有的属性
2.5使用语法
public class Poly_01 {
public static void main(String[] args) {
// 多态
Animal a = new Cat();
a.eat();
a = new Dog();
a.eat();
}
}
class Animal {
public void eat() {
System.out.println("动物吃东西");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
}
2.6多态的几种形式
public class Poly_02 {
public static void main(String[] args) {
// 1直接多态
Sup sup = new Sub();
// 2.形参和实参,方法参数列表为父类类型,调用方法传入子类对象
m1(new Sub());
// 返回值多态,返回值类型是父类类型,但是返回子类对象
Sup result = m2();
}
public static Sup m2() {
return new Sub();
}
public static void m1(Sup sup) {
}
}
class Sup {
}
class Sub extends Sup {
}
2.7多态进行属性调用
多态进行属性调用:
1.如果父类没有直接报错,不管子类有没有
2.如果父类有,子类没有,直接执行父类
3.父类和子类都有,成员方法执行子类,因为成员方法可以覆写,其他的都执行父类
4.多态又叫向上转型
public class Poly_03 {
public static void main(String[] args) {
// 多态
SupClass sup = new SubClass();
// 父类和子类都有的成员方法,执行子类
sup.m2();
// 父类没有子类有,报错
// sup.m3();
// 父类和子类都有的静态方法,执行父类
sup.m1();
// 成员变量也是父类
System.out.println(sup.i);
// 此时,由于多态原因,子类特有属性访问不到,想要访问也行,但是要先向下转型
// 必须先发生向上转型,才能发生向下转型
SubClass sub = (SubClass) sup;
sub.m3();
// 没有发生向上转型的话,如果使用向下转型会报错,类型转换异常
SupClass sup1 = new SupClass();
// SubClass sub1 = (SubClass) sup1;
// instanceof:判断某个对象是否由某个类实例化而来
if (sup1 instanceof SubClass) {
// 如果是,就向下转型,不是就不转,可以避免类型转换异常
SubClass sub1 = (SubClass) sup1;
}
}
}
class SupClass {
int i = 1;
public static void m1() {
System.out.println("父类静态方法m1");
}
public void m2() {
System.out.println("父类成员方法m2");
}
}
class SubClass extends SupClass {
int i = 2;
public static void m1() {
System.out.println("子类静态方法m1");
}
public void m2() {
System.out.println("子类成员方法m2");
}
public void m3() {
System.out.println("子类独有的成员方法m3");
}
}
2.7instanceof
判断某个对象是否由某个类实例化而来
3.abstract
3.1是什么
修饰符 修饰的类是抽象类,修饰的方法是抽象方法
抽象类 :不能实例化对象
抽象方法:没有方法体,只定义功能,没有功能的实现,并且抽象方法必须放在抽象类里面,反之,抽象类中可以没有抽象方法
abstract 和 final 不能同时出现
3.2使用语法
abstract class Animal {
// 吃饭的功能
abstract public void eat();
public void m1() {
System.out.println(this+"Animal 的m1方法");
}
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
4.interface
4.1是什么
可以理解为完全抽象的一个类,里面只有抽象方法和常量
但是从1.8开始,允许出现静态方法和默认方法
接口中的抽象方法,不需要加abstract修饰,方法默认都是public abstract
接口中没有变量,只有常量,并且public static final 可以省略
类和接口之间,不再是继承关系,变成了实现关系,由extends换成了implements
接口名 变量= new 子实现类() 也是会发生多态的
一个类 只能继承一个类,但是 可以实现N个接口,以逗号隔开,可以解决单继承功能变弱问题
class 类名 implements 接口1,接口2,…{}
接口和接口之间是多继承,多个以逗号隔开
interface 接口名 extends 父接口名1,父接口名2,…{}
一个类如果实现了一个接口,那么必须实现接口中所有的抽象方法,否则该类需要加abstract修饰
一个抽象类实现一个接口可以实现0-N个抽象方法
1.7及之前只能有抽象方法
1.8可以有静态方法,也可以有default方法(就理解为成员方法即可)
静态方法,用接口名调用即可
default 方法需要通过子实现类调用,同时也可以覆写
1.9开始支持private方法
如果接口和抽象类都能做到一件事,优先使用接口,因为这样会保留类的继承
4.2使用方式
语法:修饰符 interface 接口名 {}
public class interface_01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
interface A {
public static final String name = "xxx";
int age = 18;
public abstract void m1();
void m2();
public default void m3() {
System.out.println("默认方法");
}
public static void m4() {
System.out.println("静态方法");
}
}
interface B {
}
interface C extends A, B {
}
class D implements A, B, C {
@Override
public void m1() {
}
@Override
public void m2() {
}
}
abstract class E implements A, B, C {
}
5.object
5.1概述
Object 是所有类的祖类,是java中提供的根类。一个类没有显示继承另一个类的时候,默认继承object
Object xx = new xxx();的时候是可以发生多态的
5.2equals
==:比较基本类型的时候,比较值的大小,但是比较引用类型的时候,比较的是内存地址
而比较内存地址是没有任何价值的,我们一般会比较两个对象的属性值是否一致,而不是比较两个对象的地址是否一致
equals():该方法设计目的,用来比较两个对象是否相等,但是默认比较地址
java中Object里面的equals方法,默认比较内存地址,需要我们根据需求进行重写
public class Equals_01 {
public static void main(String[] args) {
Student s1 = new Student(2018, "张三");
Student s2 = new Student(2018, "张三");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}
class Student {
int id;
String name;
public Student(int id, String name) {
super();
this.id = id;
this.name = name;
}
// 需求: 如果两个学生的ID相同 就认为这两个是同一个学生
// 需求 : 如果两个学生的ID和姓名都相同 就认为这两个是同一个学生
@Override
public boolean equals(Object obj) {
// 判断是不是同一个对象
if (this == obj) {
return true;
}
// 向下转型,因为此时传进来的参数用不到子类的特有属性
if (obj instanceof Student) {
// if(this.id==obj.id;){
// }
// 向下转型
Student s2 = (Student) obj;
// String类中覆写了equals方法,比较的是值
if (this.id == s2.id && this.name.equals(s2.name))
return true;
}
return false;
}
}
5.3 finalize
该方法会在垃圾被回收的时候自动调用,无程序员手动调用
垃圾:当一个对象没有更多引用指向它的时候,该对象被视为垃圾数据(就是创建了一个对象,谁也找不到他)finalize方法没有回收功能,手动调用的话,只是单纯的方法调用而已
public class Finalize_01 {
public static void main(String[] args) {
Person p = new Person();
p=null;
// finalize方法没有回收功能,手动调用的话,只是单纯的方法调用而已
// 程序员可以建议进行垃圾回收,但是回收不回收就是另一回事了
System.gc();
}
}
class Person {
@Override
protected void finalize() throws Throwable {
System.out.println(this + "我要被回收了");
}
}
5.4toString
toString 代表了当前对象的字符串表示形式
当我们打印一个引用类型变量的时候,会自动调用该对象的toString方法
而Object中默认的toString方法是打印该对象的内存地址(hash值)
public class ToString_01 {
public static void main(String[] args) {
Person p1 = new Person("张三", 18);
System.out.println(p1);
System.out.println(p1.name + ":" + p1.age);
}
}
class Person {
String name;
int age;
@Override
public String toString() {
return "我是" + this.name + ":" + this.age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
}