1.(扩展)成员变量 VS 局部变量:在同一个范围内不能声明同名的变量,在不同范围内可以有同名的变量.
1.1:声明位置不同:成员变量在类中直接声明;局部变量在方法中声明.
1.2:生命周期不同:成员的生命周期随着对象创建而产生,随着对象销毁而结束;局部变量的生命周期仅在声明的方法中.
1.3:作用域不同:成员变量的作用由访问修饰符决定;局部变量的作用在声明它的大括号中.
1.4:默认初值不同:成员变量不赋值有默认值,String类型默认值是null,int类型默认值0,double类型默认值0.0,boolean类型默认值false,char类型默认值是\u0000;局部变量不赋值没有默认值.
1.5:访问修饰符不同:成员变量一定有访问修饰符;局部不能用访问修饰符.
1.6:在内存中位置不同:成员变量声明在内存堆中;局部变量声明在内存的栈中.
1.7:优先级不同:当成员变量和局部变量同名时,局部变量的优先级更高.
2.Object:是所有java类的根类,所有的Java类都直接或间接继承Object类.
常用方法:
2.1:toString():返回对象的字符串表示形式。
注意:如果当前对象所有类中没有重写toString(),只是从Object类继承,当前对象调用toString()输出的是内存地址.
如果当前对象所有类中重写了toString(),当前对象调用toString()输出的是重写的内容.
2.2:hashCode():返回对象的哈希码值。每个对象调用hashCode()时都可以得到唯一一个
哈希码值,如果两个对象指向同一块内存地址,它们的哈希码值才相同.
2.3:== vs equals()
==:==左右两边的变量是基本数据类型,比的是两个变量的值;==左右两边的变量是 引用数据类型,比的是两个变量的内存地址.
equals():equals()左右两边变量所在类如果没有重写equals(),而是直接从Object继承的,那么equals()的作用比内存地址;equals()左右两边变量所在类重写equals(),那么equals()比较的是两个变量的值.
注意:String类底层重写Object的equals(),所以String类的变量调用equals()比的是变量的值.
eg:public static void main(String[] args) {
//创建对象
Student stu1=new Student("张三", 80);
Student stu2=new Student("张三", 80);
int num1=11;
int num2=11;
//==左右两边是基本数据类型,比值
System.out.println(num1==num2);//true
//==左右两边是引用数据类型,比地址
System.out.println(stu1==stu2);//false
//stu1和stu2两个变量所在类Student类没有重写equals(),而这两个变量是引用数据类型,比地址
//stu1和stu2两个变量所在类Student类重写equals(),比值
System.out.println(stu1.equals(stu2));//false//true
}
3.final:最终的,可以修饰类,方法,变量.
3.1:最终类(断子绝孙类):用final修饰的类叫最终类.最终类不能被继承.
3.2:最终方法:用final修饰的方法叫最终方法.最终方法不能被重写.
3.3:常量:用final修饰的变量叫常量.常量一生只能赋一次值,一但赋值不可更改.
成员常量:可以在声明的同时赋值,还可以构造方法中给成员常量赋值.
局部常量:可以在声明局部常量时直接赋值,还可以先声明局部常量,再赋值
eg:public class Pet {
public String nickName;
public String breed;
//成员常量在声明直接赋值
public final int age=11;
//声明成员常量,用构造方法赋值
private final int height;
public Pet() {
//给常量赋值
height=170;
}
public Pet(String nickName, String breed, int height) {
super();
this.nickName = nickName;
this.breed = breed;
//给常量赋值
this.height = height;
}
/**
* 最终方法不能被重写
*/
public final void bark() {
//声明局部常量时直接赋值
final int num1=11;
//先声明局部常量,再赋值
final int num2;
num2=22;
System.out.println(nickName+"在叫");
}
}
4.多态:也是面向对象的三大特性之一.
4.1:多态概念:
生活中多态:同一种事物在不同条件执行不同的操作.
程序中多态:由同一个父类或父接口作为数据类型,指向不同子类对象,调用相同的方法,执行不同操作叫多态.
4.2:多态应用:
4.2.1:用父类或父接口作为数据类型,创建不同的子类对象,调用子类重写父类的方法而执行不同的操作.
//新建一个宠物类
public class Pet {
private String cname; //宠物名
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
public void print(){
System.out.println("打印宠物类的信息:");
}
//有猫
public class Cat extends Pet {
@Override
public void print() {
System.out.println("猫咪的打印信息:");
}
}
//有狗
public class Dog extends Pet {
@Override
public void print() {
System.out.println("狗狗的描述信息");
}
}
//新建一个主人类定义两个方法
public class Master {
private String name; //主人名
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void feed(Pet pet){ //注意:不要看是谁调的,要看谁传的
//多态:父类引用对象指向子类对象,可调用子类重写的方法
String cname = pet.getCname(); //继承性
System.out.println("主人"+name+"给"+cname+"喂食");
pet.print(); //主人给宠物喂食..给谁?,调的是子类重写方法--多态性
}
public Pet adopt(int num) { //领养宠物的方法
if(num==1){
Dog dog = new Dog();
return dog; //返回狗对象
}else if(num==2){
Cat cat = new Cat();
return cat; //返回猫对象
}
return null;
}
}
//新建一个测试类
public class Test9_9 {
public static void main(String[] args) {
//1 使用父类作为方法形参实现多态
Master master = new Master(); //实例化主人、猫、狗的对象
// master.setName("张三疯");
// Cat cat = new Cat();
// cat.setCname("大脸猫");
//
// Dog dog = new Dog();
// dog.setCname("招财狗");
// master.feed(cat); //主人给猫喂食
// master.feed(dog); //主人给狗喂食
//2 使用父类作为方法返回值实现多态
System.out.println("请输入你要领养的宠物:1.狗狗,2:猫咪");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
Pet pet = master.adopt(num); //父类对象指向子类对象
//NullPointerException: 当为null时,调了属性或方法,则会出现空指针异常
if(pet != null){
pet.print(); //可调用子类重写方法
}else{
System.out.println("没有返回的宠物对象...");
}
}
}
5.引用类型数据转换
5.1:向上转型:将子类对象存在父类变量中叫向上转型.向上转型是自动类型转换.
语法:父类型 变量名=子类对象;
eg:Pet c1=new Cat();
Pet d1=new Dog();
5.2:向下转型:将父类类型的变量转换为原来子类对象叫向下转型.向下转型是强制类型转换.
5.2.1:语法:子类类型 变量名=(子类类型)父类变量;
5.2.2:向下转型的适用场景:用父类作为数据类型,创建的子类对象,只能调用从父类继承的方法,或者从父类继承过来重写的方法,调不出子类独有方法,想调用子类独有的方法,就要向下转型.
eg:public static void main(String[] args) {
//创建对象
Pet p1=new Cat();
Pet p2=new Dog();
//用对象调用方法
p1.bark();
p1.eat();
p2.bark();
p2.eat();
//用父类作为数据类型,创建的子类对象,只能调用从父类继承的方法,或者从父类继承过来重写的方法,调不出子类独有方法.
//这时就需要用向下转型,将父类型的变量转换成子类原本的类型
Cat c2=(Cat) p1;
Dog d2=(Dog) p2;
//用子类原来类型调用子类独有方法
c2.catchMice();
d2.watchDoor();
}
5.3:向下转型有风险,为了解决这个风险,在向下转型之前要进行类型判断
语法:boolean result=变量名 instanceof 子类类型
eg:public static void main(String[] args) {
//创建对象
Pet p1=new Cat();
Pet p2=new Dog();
//向下转型有风险,转换的类型有误会报类型转换异常,为了解决类型转换异常,转换之前先作类型判断
if(p2 instanceof Dog) {
Dog d2=(Dog) p2;
d2.watchDoor();
}else if(p2 instanceof Cat) {
Cat d2=(Cat) p2;
d2.catchMice();
}
}