21.构造方法(续):
分类:
隐式构造方法:如果在一个类中,没有手动编写构造方法,则系统会提供一个默认的无参的构造方法
显式构造方法:如果在一个类中,手动编写构造方法,则系统不会提供默认的无参的构造方法
建议:当手动编写构造方法时,建议先编写无参构造方法
22.引用数据类型
String
用户自定义类型,如:Teacher、Student
注意:引用数据类型赋值两种方式:赋值对象,赋值为null
小知识点:当一个对象作为另一个对象的属性
或者当一个对象中的属性是引用数据类型
23.空指针异常
java.lang.NullPointerException
出现空指针异常原因:说明该引用名称中存放的不是某个对象的地址,也就是null
解决办法:在调用某个对象中的属性或方法之前,必须保证该引用名称存放的是对象的地址
24.封装
24.1面向对象三大特征:封装、继承、多态
24.2封装
隐藏类的内部信息,不允许外部程序直接访问,而是通过方法进行操作
24.3封装的操作步骤:
第一步:将属性设置为私有的private,只能在本类中使用
private int age;
第二步:设置属性的get取值和set赋值方法
//赋值方法
public void setAge(int age){
//第三步:适当位置编写判断语句
if(age >= 0 && age <= 120){
this.age = age;
}else{
this.age = 21;
}
}
//取值方法
public int getAge(){
return age;
}
* 编写人Person类,属性:名字、年龄、性别,通过封装完成对属性赋值和取值 */ class Person{ //属性 private String name; private int age; private char sex; //编写所有属性的赋值方法 public void setName(String name){ this.name = name; } public void setAge(int age){ //当年龄在0---120为合法的,否则为21 if(age >= 0 && age <= 120){ this.age = age; }else{ this.age = 21; } } public void setSex(char sex){ //性别只能是男或女,否则性别为女 if(sex == '男' || sex == '女'){ this.sex = sex; }else{ this.sex = '女'; } } //编写所有属性的取值方法 public String getName(){ return name; } public int getAge(){ return age; } public char getSex(){ return sex; } } //编写人的测试类 class PersonTest{ public static void main(String[] args){ //实例化Person Person p = new Person(); p.setName("李四"); p.setAge(23); p.setSex('n'); System.out.println("姓名:" + p.getName() + "\n年龄:" + p.getAge() + "\n性别:" + p.getSex()); } }
25.this关键字
this代表当前这个对象,也就是说当前谁调用该方法则this代表就是谁
this关键字可以访问当前类中的属性、方法、也可以访问构造方法
注意:
1.当访问本类中的非静态方法和属性时,默认前面添加this.
2.当访问本类中的构造方法时,必须编写在构造方法中,并且是第一条语句
3.构造方法不能出现递归调用
26.参数传递
26.1基本数据类型作为参数传递----传递值
总结:当基本数据类型作为参数进行传递时,传递的是值,当有一个方法中的值发生改变,则对另一个方法中的值没有任何影响(各自是独立的)
26.2引用数据类型作为参数传递----传递地址
总结:当引用数据类型作为参数传递时,传递的是地址,当一个方法中属性的值发生改变时,对另一个方法中的属性值有影响(共用同一个地址)
27.static关键字
27.1 static关键字可以修饰属性
---该属性在方法区中开辟空间
---访问时可以使用类名.属性名称、引用名称.属性名称,当引用名称的值为null时也可以访问
如:Student.address
stu.address
stu = null;
stu.address
---与类同生死,生命周期长
---类优先于对象
27.2好处:节省空间
27.3.3static关键字可以修饰方法
注意:
1.静态方法中只能访问静态属性和方法
2.实例方法中可以访问静态的属性和方法,也可以访问实例属性和方法
3.3static关键字可以修饰代码块 ,称为静态代码块
static{
}
作用:完成静态属性赋值的
注意:1.当类被第一次载入时,静态代码块就自动执行
建议:当调用静态属性或静态方法时,使用类名
练习:
编写一个狗类,属性:名字、颜色、年龄、品种,方法:输出信息
编写一个猫类,属性:名字、颜色、年龄,方法:输出信息
编写测试类,分别创建猫和狗的对象,输出信息
分析:发现以上猫类和狗类中有相同的属性、方法,能否将共有的属性和方法编写一次?
-----能
解决办法:
1.将相同的属性和方法编写在单独的一个类中,称为父类
2.然后在猫和狗子类中继承父类,并编写子类中独有的属性和独有的方法
动物Animal类:
共有属性:名字、颜色、年龄
共有方法:输出信息
狗类 继承 动物类
独有属性:品种strain
猫类 继承 动物类
/第一步:编写父类Animal class Animal{ //属性也叫做成员变量或实例变量 String name; String color; int age; //方法也叫做成员方法或实例方法 public void show(){ System.out.println("名字:" + name); System.out.println("颜色: " + color); System.out.println("年龄:" + age); } } //编写狗的子类并继承父类Animal class Dog extends Animal{ //编写独有的属性 String strain; //编写show方法,输出狗的所有信息-----方法的重写 public void show(){ System.out.println("名字:" + name); System.out.println("颜色: " + color); System.out.println("年龄:" + age); System.out.println("品种:" + strain); } } //编写猫的子类并继承父类Animal class Cat extends Animal{ } //编写测试类 class Test{ public static void main(String[] args){ //创建狗的对象,输出信息 Dog dog = new Dog(); dog.show(); //调用子类中重写后的show方法 System.out.println(); //创建猫的对象,输出信息 Cat cat = new Cat(); cat.show(); //调用父类中的show方法 } }
28.继承
28.1好处:减少代码的冗余性
28.2面向对象有三大特征:封装,继承,多态
28.3继承画类图
28.4编写继承的代码
第一步:编写父类
第二步:编写子类
class 子类名称 extends 父类名称{
}
注意:在Java中,所有类都是从Object类继承过来的,也就是说所有类的根都是Object
class Dog{
}
//等价于
class Dog extends Object{
}
也就是说如果父类是Object则可以省略不写
28.5 方法重写(override)也叫覆盖
在子类中重写父类中的方法,必须保证子类中方法的名字与父类方法名称一致、参数列表一致、返回一致或父类方法返回类型的子类类型、修饰符不能缩小范围
注意:
1.只能重写父类的实例方法
2.私有的方法不能被重写
2.继承的注意事项
---当子类继承父类时,继承父类中属性和方法,但是父类中的私有成员(成员变量和成员方法)不能被继承,以及父类中的构造方法也不能被继承
---父类也叫做超类,基类
子类也叫做派生类
---一个类只能继承一个直接的父类,也就是说类是单根性
---类具有传递性
class A{
//2个属性,3个方法
}
class B extends A{
//独有属性1个,独有方法2个
}
class C extends B{
}
28.6.super关键字
super表示父类,必须在子类中访问父类中的属性、方法也可以访问父类中的构造方法
注意:当使用super关键字访问父类中的构造方法,则必须编写在子类构造方法中,并且是第一条语句
.this关键字
this关键字可以访问当前类中的属性、方法以及构造方法
还可以访问父类中的属性、方法
28.7.当创建子类对象,父类做了什么?
----先执行父类的构造方法,然后再执行子类相匹配的构造方法
----如果子类构造方法中没有指明调用父类哪个构造方法,则默认调用父类的无参构造方法
----如果子类构造方法中指明调用父类哪个构造方法,通过super()或super(name,color,age),则调用父类相匹配的构造方法
29.多态:
多个对象调用同一个方法,则结果不同
class Person{ //属性 String name; int age; char sex; //构造方法 public Person(){ } public Person(String name,int age,char sex){ this.name = name; this.age = age; this.sex = sex; } //编写显示信息方法 public void show(){ System.out.println("姓名:" + this.name + "\n年龄:" + this.age + "\n性别:" + this.sex); } } //编写Student子类并继承Person父类 class Student extends Person{ //编写子类独有的属性:成绩 double score; //构造方法 public Student(){ } public Student(String name,int age,char sex,double score){ super(name,age,sex); this.score = score; } //编写学习的独有方法 public void study(){ System.out.println(super.name + "正在学习面向对象编程......"); } //重写显示信息方法 public void show(){ super.show(); System.out.println("成绩: " + score); } } //编写Teacher子类并继承Person父类 class Teacher extends Person{ //编写独有属性:薪资 double salary; //构造方法 public Teacher(){ } public Teacher(String name,int age,char sex,double salary){ super(name,age,sex); this.salary = salary; } //编写独有方法教学 public void teach(){ System.out.println(super.name + "正在讲面向对象编程课程。。。。。。"); } //重写父类的显示信息方法 public void show(){ super.show(); System.out.println("薪资:" + this.salary); } } //编写测试类 class Test{ public static void main(String[] args){ //创建Student对象 /*Student s = new Student(); //没有构成多态 s.show(); //先在学生类中找,如果没有找到则再去父类中找show方法*/ /*Person s2 = new Student(); //就是多态:多种形态,则只能访问父类中的属性和方法,但是优先访问子类重写以后的方法 s2.show(); //优先访问子类重写以后的方法 //s2.study(); //出现编译错误,原因:多态不能访问子类独有的属性和方法 System.out.println(s2.name); //null System.out.println(s2.age); //0 System.out.println(s2.sex); // //System.out.println(s2.score); //出现编译错误,原因:多态不能访问子类独有的属性和方法*/ //父类类名 引用名称 = new 子类类名(); /*Person p = new Student(); //构成多态 p.show(); //优先访问重写以后的方法 System.out.println(); Person p2 = new Teacher(); //构成多态 p2.show();*/ /*Teacher t = new Teacher(); //没有构成多态 t.show();*/ } } //编写第二个测试类 class Test2{ public static void main(String[] args){ //Student s = new Student(); //没有构成多态 /*System.out.println(s.name); //null System.out.println(s.age); //0 System.out.println(s.sex); System.out.println(s.score); //0.0 s.show(); s.study();*/ Person p = new Person(); //没有构成多态,注意:一般不实例化父类 /*System.out.println(p.name); //null System.out.println(p.age); //0 System.out.println(p.sex); */ //System.out.println(p.score); //编译错误 //p.show(); //访问父类中的show方法 Person person = new Student(); //构成多态,同时也是向上转型 person.show(); //必须将person引用名称转为Student类型,则才可以访问study方法 //person.study(); //编译错误 /*Student stu = (Student)person; //向下转型 stu.study(); Teacher t = (Teacher)person; //出现运行错误,原因:person引用中存放的是学生对象的地址,因此不能随意转为其他子类类型,建议在进行向下转型之前先进行判断,当合法进行向下转型,使用instanceof关键字 System.out.println(t.salary);*/ //在进行向下类型转换时可能会出现类型转换异常(java.lang.ClassCastException),进行判断 if(person instanceof Student){ //则强制转为学生 Student s = (Student)person; s.study(); }else if(person instanceof Teacher){ //则强制转为教师 Teacher t = (Teacher)person; t.teach(); } } }
29.1语法格式:
父类类名 引用名称 = new 子类类名(); //当构成多态时,只能访问父类中的属性和方法,但是优先访问子类重写以后的方法
29.2满足多态的条件:
1.必须子类继承父类
2.必须在子类中重写父类的方法
3.父类类名 引用名称 = new 子类类名();
6.3在多态中,有两种类型转换:
1.子类对象---->父类类型,称为向上转型或自动类型转换
如:Person p = new Student(); //构成多态,也是向上转型或自动类型转换
举个例子:有2个类,Father是父类,Son类继承自Father。
Father f1 = new Son(); // 这就叫 upcasting (向上转型)
// 现在f1引用指向一个Son对象
Son s1 = (Son)f1; // 这就叫 downcasting (向下转型)
当是向上转型时则只能访问父类中的属性和方法,但是优先访问子类重写以后的方法
2.父类引用名称---->子类类型,称为向下转型或强制类型转换
Student p = (Student)p;
*****注意:
1.当是多态时,并访问子类独有的属性或方法时则必须进行向下转型
2.在进行向下类型转换时可能会出现类型转换异常(java.lang.ClassCastException),建议先进行判断,满足在进行强制类型转换
30.递归:方法自己调用自己,但是必须保证要有出口
练习:使用递归完成计算n!,如:3!= 3 * 2 * 1