final关键字:
关键字是最终的意思,可以修饰类,成员,变量,成员方法。
修饰类:该类不能被继承
修饰变量:变量就变成的常量,只能被赋值一次
修饰方法:方法不能被重写
final修饰局部变量的问题:
基本类型:基本类型的值不能发生改变。
引用类型:引用类型的地址值不能发生改变,但是,该对象的堆内存的值是可以改变的。
final修饰变量的初始化时机
A:被final修饰的变量只能赋值一次。
B:在构造方法完毕前。(非静态的常量)
多态:
多态的前提:
A:要有继承关系。
B:要有方法重写。
其实没有也是可以的,但是如果没有这个就没有意义。
动物 d = new 猫();
d.show();
动物 d = new 狗();
d.show();
C:要有父类引用指向子类对象。
父 f = new 子();
多态中的成员访问特点:
A:成员变量
编译看左边,运行看左边。
B:构造方法
创建子类对象的时候,访问父类的构造方法,对父类的数据进行初始化。
C:成员方法
编译看左边,运行看右边。
D:静态方法
编译看左边,运行看左边。
(静态和类相关,算不上重写,所以,访问还是左边的)
由于成员方法存在方法重写,所以它运行看右边。
多态中的转型问题:
多态的弊端:
不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?
行。
怎么用呢?
A:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)
对象间的转型问题:
向上转型:
Fu f = new Zi(); 转成爹就可以用爹的技能。
向下转型:
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
例子:
/* 多态的弊端: 不能使用子类的特有功能。 我就想使用子类的特有功能?行不行? 行。 怎么用呢? A:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,太占内存了) B:把父类的引用强制转换为子类的引用。(向下转型) 对象间的转型问题: 向上转型: Fu f = new Zi(); 向下转型: Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。 */ class Fu { public void show() { System.out.println("show fu"); } } class Zi extends Fu { public void show() { System.out.println("show zi"); } public void method() { System.out.println("method zi"); } } class test1 { public static void main(String[] args) { //测试
//向上转型 Fu f = new Zi(); f.show(); // f.method(); //创建子类对象 // Zi z = new Zi(); // z.show(); // z.method(); //你能够把子的对象赋值给父亲,那么我能不能把父的引用赋值给子的引用呢? //如果可以,但是如下
//向下转型
Zi z = (Zi)f; z.show(); z.method(); } }
抽象类:
抽象类的概述:
动物不应该定义为具体的东西,而且动物中的吃,睡等也不应该是具体的。
我们把一个不是具体的功能称为抽象的功能,而一个类中如果有抽象的功能,该类必须是抽象类。
抽象类的特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
C:抽象类不能实例化
因为它不是具体的。
抽象类有构造方法,但是不能实例化?构造方法的作用是什么呢?
用于子类访问父类数据的初始化
D:抽象的子类
a:如果不想重写抽象方法,该子类是一个抽象类。
b:重写所有的抽象方法,这个时候子类是一个具体的类。
抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
Animal a = new Cat();
abstract class Animal { //抽象方法 //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体 public abstract void eat(); public Animal(){} } //子类是抽象类 abstract class Dog extends Animal {} //子类是具体类,重写抽象方法 class Cat extends Animal { public void eat() { System.out.println("猫吃鱼"); } } class AbstractDemo { public static void main(String[] args) { //创建对象 //Animal是抽象的; 无法实例化 //Animal a = new Animal(); //通过多态的方式 Animal a = new Cat(); a.eat(); } }
抽象类的成员特点:
成员变量:既可以是变量,也可以是常量。
构造方法:有。
用于子类访问父类数据的初始化。
成员方法:既可以是抽象的,也可以是非抽象的。
抽象类的成员方法特性:
A:抽象方法 强制要求子类做的事情。
B:非抽象方法 子类继承的事情,提高代码复用性。
注意:
一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
A:可以。
B:不让创建对象。
abstract不能和哪些关键字共存?
private 冲突
final 冲突
static 无意义(无方法体)
匿名内部类实现抽象方法:
abstract class Animal{ //这里使用匿名内部类实现抽象方法,就是在用的时候实现抽象方法。 public abstract void run(); public abstract void shout(); public void eat(){ System.out.println("吃东西"); } } abstract class Cat extends Animal { public void shout(){ System.out.println("喵喵,cat"); }; } public class chouxiang { public static void main(String[] args){ Animal cat = new Cat(){//匿名内部类 public void run(){ System.out.println("爬树"); } }; cat.shout(); cat.run(); } }
接口interface:
命令特点:Inter+接口名
与主要用于扩展作用,有点像电脑的usb接口。
jdk8开始可以在接口中定义一个default修饰的实现方法
接口的特点:
A:接口用关键字interface表示
interface 接口名 {}
B:类实现接口用implements表示
class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式来实例化。
D:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
小总结:
A:具体类多态(几乎没有)
B:抽象类多态(常用)
C:接口多态(最常用)
接口成员的特点:
接口中变量的格式:public static final xxxxx
如果你的变量没有达到这样的话,他也会给你转换成这样的。
建议按标准写,写全。
成员变量;只能是常量,并且是静态的。
默认修饰符:public static final
建议:自己手动给出。
构造方法:接口没有构造方法。是类自己默认继承object类
成员方法:只能是抽象方法。
默认修饰符:public abstract
建议:自己手动给出。
所有的类都默认继承自一个类:Object。
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
类和接口,接口和接口:
/* 类与类: 继承关系,只能单继承,可以多层继承。 类与接口: 实现关系,可以单实现,也可以多实现。 并且还可以在继承一个类的同时实现多个接口。 接口与接口: 继承关系,可以单继承,也可以多继承。 */ interface Father { public abstract void show(); } interface Mother { public abstract void show2(); } //继承多个接口 interface Sister extends Father,Mother { } //class Son implements Father,Mother //多实现 class Son extends Object implements Father,Mother { public void show() { System.out.println("show son"); } public void show2() { System.out.println("show2 son"); } } class InterfaceDemo3 { public static void main(String[] args) { //创建对象 Father f = new Son(); f.show(); //f.show2(); //报错 Mother m = new Son(); //m.show(); //报错 m.show2(); } }
抽象类和接口的区别:
抽象类和接口的区别:
A:成员区别
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
B:关系区别
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承
C:设计理念区别
抽象类 被继承体现的是:”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是:”like a”的关系。接口中定义的是该继承体系的扩展功能。
面向对象中的形式参数,返回值类型:
形式参数:
基本类型(太简单,不是我今天要讲解的)
引用类型
类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
抽象类:需要的是该抽象的类子类对象
接口:需要的是该接口的实现类对象
interface Love { public abstract void love(); } class LoveDemo { public void method(Love l) { //l; l = new Teacher(); Love l = new Teacher(); 多态 l.love(); } } //定义具体类实现接口 class Teacher implements Love { public void love() { System.out.println("老师爱学生,爱Java,爱林青霞"); } } class TeacherTest { public static void main(String[] args) { //需求:我要测试LoveDemo类中的love()方法 LoveDemo ld = new LoveDemo(); Love l = new Teacher(); ld.method(l); } }
接口,类,抽象类返回参数:
/* 返回值类型 基本类型:(基本类型太简单,我不准备讲解) 引用类型: 类:返回的是该类的对象 抽象类:返回的是该抽象类的子类对象 接口:返回的是该接口的实现类的对象 */ //定义一个爱好的接口 interface Love { public abstract void love(); } class LoveDemo { public Love getLove() { //Love l = new Teacher(); //return l; return new Teacher(); } } //定义具体类实现接口 class Teacher implements Love { public void love() { System.out.println("老师爱学生,爱Java,爱林青霞"); } } class TeacherTest2 { public static void main(String[] args) { //如何测试呢? LoveDemo ld = new LoveDemo(); Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态 l.love(); } }
instanceof 关键字:
在java中可以使用instanceof关键字判断一个对象到底是那个类的实例
对象 instanceof 类 à 返回boolean类型
public class Shout {
//调用动物叫的方法,如果是兔子的化,兔子提示爱吃胡萝卜
public void call(Animal a){ // dog cat rabbit
if(a instanceof Rabbit){//a 传的对象是Rabbit对象
System.out.println("兔子提示爱吃胡萝卜");
}
//如果是猫,打印会爬树
if(a instanceof Cat){
System.out.println("小老虎会爬树");
}
a.shout();
}
}
Object类:
使用toString方法来打印类的属性
System.out.println(cat.toString());
com.zym.chouxiang$1@1b6d3586
这里他打印的结果是个内存的地址
我们需要的是属性的值,这里我们重写toString方法来实现打印属性的方法。
@Override public String toString() { //Person [age=20, name=张三] return "Person [age=" + age + ", name=" + name + "]"; }
equals()方法:
一般使用自动生成的就可以,alt+insert
包装类介绍:
在Java的设计中提倡一种思想:“一切皆对象”,那么这样一来就出现了一个矛盾,从数据类型的划分中可以知道JAVA中的数据类型分为基本数据类型和引用数据类型,但是基本数据类型怎么能够称为对象呢?此时,就需要将基本数据类型进行包装,将八种基本类型变为一个类的形式,那么这也就是包装类的作用。
No. |
基本数据类型 |
包装类 |
1 |
int |
Integer |
2 |
char |
Character |
3 |
short |
Short |
4 |
long |
Long |
5 |
float |
Float |
6 |
double |
Double |
7 |
boolean |
Boolean |
8 |
byte |
Byte |
//基本数据类型和包装类型是自动转换的,装箱和拆箱
int a=10;
Integer a1=a;
Integer in= new Integer(a);// 装箱
int aa=in;// 拆箱
System.out.println(aa);
装箱:
将一个基本数据类型变为包装类,这样的过程称为装箱操作
拆箱:
将一个包装类变为基本数据类型这样的过程称为拆箱操作
转换操作:
public class Test { public static void main(String[] args) { //基本数据类型和包装类型是自动转换的,封箱和拆箱 int a=10; Integer a1=a; Integer in= new Integer(a); int aa=in; System.out.println(aa); //把一个字符串类型的数字,转成对应的数字 String str1 = "123"; str1=str1+1; System.out.println(str1); int num1 = Integer.parseInt(str1); num1++; System.out.println(num1); String str2 ="10.98"; System.out.println(new Float(str2)); System.out.println(Float.parseFloat(str2)); // Scanner sc = new Scanner(System.in); // String age=sc.next(); // User user = new User(); // user.setAge(new Integer(age)); } }