static
- static特点
问题: - static关键字的运用有什么好处?
- static可以修饰哪些代码部分?
- 被static修饰的内容,推荐如何调用?
概述:static关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法、成员变量
修饰的成员变量叫静态变量
修饰的成员方法叫静态方法
static修饰的特点:
被该类所有的对象所共享
随着类的加载而加载,优先于对象存在
可以通过类名调用,也可以通过对象名调用。推荐使用类名调用
public class Student {
static String name;
int age;
static String school;
…
}
public class Test01 {
public static void main(String[] args) {
//2.被static修饰的成员,多了一种调用方式,可以通过 “类名.静态成员” 进行调用
Student.school=“厦门大学”;
System.out.println(Student.school);
School.study();//1.被static修饰的成员变量会被所有对象共享 Student stu1 = new Student("张三", 19, "清华大学"); stu1.show(); Student stu2 = new Student("李四", 20, "北京大学"); stu2.show(); //再用张三调用show方法 stu1.show();//效果是学校改变了,但是张三并没有修改学校信息 //只有李四有修改学校信息,证明了被static修饰的成员变量会被所有对象共享}
}
2. 注意事项
问题:
1.为什么在main方法中不能直接调用本类的其他非静态方法?
2.静态方法中,能否使用this关键字?
注意事项:
静态方法中,只能访问静态的成员变量和成员方法
在非静态方法中,可以使用静态成员,也可以使用非静态成员
静态方法中,没有this关键字
3. 代码块
问题:
1.什么是代码块?
3.每种代码块,它的作用是什么?
概述:在Java中,使用 { } 括起来的代码被称为代码块
代码块分类:
局部代码块
位置: 方法中定义
作用: 限定变量的生命周期,及早释放,提高内存利用率
构造代码块
位置: 类中方法外定义
特点: 每次构造方法执行的时,都会执行该代码块中的代码,并且在构造方法执行前执行
作用: 将多个构造方法中相同的代码,抽取到构造代码块中,提高代码的复用性
静态代码块
位置: 类中方法外定义
特点: 需要通过static关键字修饰,随着类的加载而加载,并且只执行一次
作用: 在类加载的时候做一些数据初始化的操作
代码案例:
class Student {
{
System.out.println(“好好学习”);
}
public Student(){
System.out.println(“空参数构造方法”);
}
public Student(int a){
System.out.println(“带参数构造方法…”);
}
}
public class TestStudent {public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student(10);
}
}
class Person {
static {
System.out.println(“我是静态代码块, 我执行了”);
}
public Person(){
System.out.println(“我是Person类的空参数构造方法”);
}
public Person(int a){
System.out.println(“我是Person类的带…参数构造方法”);
}
}
public class TestPerson {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person(10);
}
} - 单例设计模式
设计模式
在软件开发中经常会遇到一些问题,这些问题如何解决,前人总结了一些好的方法,这些方法就称之为设计模式
用设计模式去解决这些问题,可以使代码的安全性、重用性、扩展性更强
单例模式
在开发中我们经常会遇到这么一个问题:在设计类时,要保证这个类的实例对象只能有一个
单例模式就是可以让类只能由一个对象的写代码方式
使用场景
任务管理器对象我们只需要一个就可以解决问题了,这样可以节省内存空间 - 继承入门
问题: - 学习继承有什么作用,在什么时候可以使用?
- 如何使用继承,优化我们的黑马信息管理系统?
概述:让类与类之间产生关系(子父类关系),子类则可以使用父类中非私有的成员
继承的格式:
格式:public class 子类名 extends 父类名{ }
范例:public class Zi extends Fu{ }
Fu:是父类,也被称为基类、超类
Zi:是子类,也被称为派生类
课堂案例:
-
继承的好处和弊端
问题:
1.继承是如何提高代码的可维护性?
2.什么是代码的耦合性?
3.什么时候可以使用继承优化代码?
继承好处
提高了代码的复用性
提高了代码的维护性
让类与类之间产生了关系,是多态的前提
继承弊端
增强了代码的耦合性:代码与代码之间存在关联都可以将其称之为"耦合"
继承是侵入性的
降低了代码的灵活性:继承关系,导致子类必须拥有父类非私有属性和方法,让子类自由的世界中多了写约束
继承的使用场景
需要考虑类与类之间是否存在is…a的关系,不能盲目使用继承
is…a的关系:谁是谁的一种,例如:
老师和学生是人的一种,那人就是父类,学生和老师就是子类
猫和狗的关系:猫和狗都是动物的一种,那动物就是父类,猫和狗就是子类 -
Java中继承的特点
问题:
1.java中使用多层继承的好处是什么?
2.为什么java不支持多继承?
特点:Java中类只支持单继承,不支持多继承,但支持多层继承
支持单继承,不支持多继承:一个类只能继承一个父类,不同同时继承多个类
错误范例1: class 儿子 extends 亲爹,干爹{ }
错误范例2: class 儿子 extends 亲爹 extends 干爹{ }
Java中类支持多层继承:父类继承爷爷类,再让儿子类继承父类。这样儿子类就可以使用父类和爷爷类的共有内容了
不支持多继承的原因:如果可以多继承,两个父类有完全相同的方法,子类究竟使用谁的呢?
//练习场景:假设儿子类既想拥有父亲的驾驶能力,也想拥有爷爷的喝酒天赋,就可以使用多层继承
//1.有爷爷类
public class 爷爷{
public void drink(){
System.out.println(“日饮三斤”);
}
}
//2.让父亲类继承爷爷类
public class 父亲 extends 爷爷{
//父亲拥有自己的驾驶方法
public void driver(){
System.out.println(“秋名山车神,漂移过弯”);
}
}
//3.让儿子继承父亲类
public class 儿子 extends 父亲{
//用一个方法,可以同时调用父亲和爷爷的方法
public void extendsMethod(){
drink();
driver();
}
} -
继承中变量的访问特点
问题: -
在子类方法中,访问一个子类和父类中同名的成员变量,默认访问谁的?
-
在子类方法中访问变量,访问查找的顺序是怎样的?
-
如果要指定访问父类的成员变量,可以如何处理?
在子类方法中访问一个变量,采用的是就近原则。
子类局部范围找。在方法栈内存当中搜搜
子类成员范围找。方法栈中找不到,因为对象调用方法的联系,索引到该对象存在的堆内存空间
父类成员范围找。说明子类对象堆内存空间,持有了父类对象的堆内存空间地址
如果都没有就报错(不考虑父亲的父亲…)
注意事项:
如果子父类,出现了重名的成员变量,通过就近原则,会优先使用子类的
如果一定要使用父类的,可以通过super关键字,进行区分
代码练习:
public class Fu {
private String name = “张三”;
private int age = 35;
String car = “兰博基尼”;
public void drive() {
System.out.println(name + “驾驶着” + car + “在环线上驰骋”);
}
…
}
public class Zi extends Fu {
private String name = “张三丰”;
private int age = 18;
String car = “五菱宏光”;
public void drive() {
System.out.println(name + “驾驶着” + car + “在环线上驰骋”);
//通过super关键字,访问父类的成员变量
System.out.println(name + “驾驶着” + super.car + “在环线上驰骋”);
}
…
}
//测试类代码:
Fu fu = new Fu();
Zi zi = new Zi();
fu.drive();
zi.drive();
//1.儿子的内容并没有设置成功,因为父类的属性私有了,继承过来的set方法实际上是给父类对象赋值
//2.让自己也拥有setget方法
//3.如果父类和子类有同样的私有成员,子类必须重写自己的setget方法
// 如果想要让Zi类对象调用drive方法,打印的内容是驾驶父类对象的车,应如何处理
//4.如果手动创建父类和子类对象,要想让子类对象使用到父类对象的属性值,先给定
模拟场景:酷狗音乐的皮肤切换
默认皮肤(子类):父类皮肤(父类):
有时候要用子类默认的属性,有时候要用父类的属性,怎么办?
5. this和super访问成员的格式
问题:
1.super和this分别代表什么?
2.super访问父类成员方法的格式是怎样的?
3.能否通过"super.父类名()"的形式访问父类空参构造方法?
super关键字的用法和this关键字的用法相似:
this:代表本类对象的引用
super:代表父类存储空间的标识(可以理解为父类对象引用)
public void toggle() {
//1.给flag做求反操作,每调用一次toggle方法,flag就取相反的值
flag = !flag;
//2.这个现象就和灯盘开关是一样的
//3.要根据flag的值去切换主题
//默认是false,切换之后变成true
if (flag) {
//变成ture要能显示咖啡色,咖啡色是父类的属性
//所以使用super.父类的风格,把咖啡色拿到,给本类的face赋值
//因为show方法打印的是face,如果给style赋值,打印的是face,就没有变化
face = super.style;
} else {
//如果flag是false,显示默认主题,拿到当前类的属性,利用this
//当前类属性值蓝色,给face赋值,利用show方法打印蓝色
face = this.style;
}
show();
}
}
6. 继承中成员方法的访问特点
PC端微信聊天功能列表:表情、文件、截图、聊天记录、直播、语音聊天PC端企业微信聊天功能:表情、文件、截图、聊天记录、直播、图片、微文档、发起收款、会议、应用等等
如果是微信是父类,企业微信是子类,为了提高代码的复用性,相同功能可以直接使用父类的;
这就涉及到继承中,子类对象访问父类成员方法的情况;
而且两个微信中,企业微信和微信的表情库不一样,那么就存在子类和父类有同名方法的情况,这种时候我们该如何处理呢?
问题:- 如果子类和父类有同名的方法,在子类中访问该方法,访问的是谁的?
- 通过子类对象访问成员方法,查找的顺序是怎样的?
通过子类对象访问一个方法
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)
public class Fu {
public void show() {
System.out.println(“父类的show方法”);
}
}
public class Zi extends Fu {
public void show() {
System.out.println(“子类的show方法”);
//访问父类show方法
super.show();
}
}
public class Test01 {
public static void main(String[] args) {
//创建子类对象
Zi zi = new Zi();
zi.show();
}
}
7. 方法重写概述和应用场景
有时候,儿子的某些能力会比老子更强
比如,老王和他老婆王思聪和他的老婆们
既然儿子的功能更优秀,那么如何在代码上体现青出于蓝而胜于蓝呢?
问题:
1.什么时候是方法重写,代码格式有什么特点?
2.方法重写的作用是什么,在什么时候能用到?
方法重写概述
子类出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)
方法重写的应用场景
当子类需要父类的功能,而功能主体子类有自己特有内容,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容
代码案例
class OldToiletSeat{
public void function() {
System.out.println(“防止沾到尿,保护屁屁的卫生”);
}
}
class NewToiletSeat extends OldToiletSeat{
public void function() {
super.function();
System.out.println(“保温,让你的冬天不再寒冷”);
System.out.println(“水洗,让你的菊花不再疼痛,舒爽一整年”);
}
}
public class Test01 {
public static void main(String[] args) {
OldToiletSeat oldToiletSeat = new OldToiletSeat();
oldToiletSeat.function();
System.out.println(“====================”);
NewToiletSeat newToiletSeat = new NewToiletSeat();
newToiletSeat.function();
}
} -
方法重写的注意事项
问题: -
父类中哪些方法是无法被子类重写的?
-
子类重写父类的方法时,对于方法的访问权限有什么要求?
父类中私有方法不能被重写
父类静态方法,子类必须通过静态方法进行重写,父类非静态方法,子类也必须通过非静态方法进行重写
静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法。可以理解为,子类将父类中同名的方法隐藏了起来,并非是方法重写!
子类重写父类方法时,访问权限必须大于等于父类(public > 默认 > 私有)
Override注解:
用来检测当前的方法,是否是重写的方法,起到【校验】的作用
//案例
public class Fu {
private void show() {
System.out.println(“Fu中show()方法被调用”);
}
void method() {
System.out.println(“Fu中method()方法被调用”);
}
}
public class Zi extends Fu {
@Override
private void show() {
System.out.println(“Zi中show()方法被调用”);
}
- 继承中构造方法的访问特点
- 创建子类对象时,是否会先初始化父类对象?
- 调用子类的有参构造方法时,会调用父类的什么构造方法?
- 如果一个类没有指明继承关系,那么它就没有父类吗?
子类中所有的构造方法默认都会访问父类中无参的构造方法
原因:
子类在初始化的时候,有可能会使用到父类的数据,如果父类没有完成初始化,子类将无法使用父类的数据。所以,子类初始化之前,一定要先完成父类数据的初始化。
怎样完成初始化:
构造方法的第一条语句默认都是:super()
注意:
如果我们编写的类,没有手动指定父类,系统也会自动继承Object(Java继承体系中的最顶层父类)
如果父类只有有参的构造方法,在子类定义构造方法中,要实现空参构造的话,要先执行父类的有参构造,及super(*)的格式。
/ - 案例:分别创建一个父类Person和一个子类Student
- 1.分别添加父类、子类的空参、有参构造
- 2.分别在父类、子类的空参、有参构造中添加可以识别的打印语句
- 3.在测试类中创建子类对象,查看父类、子类的构造方法调用情况
*/
- 构造方法的访问特点:父类没有空参构造方法
问题:
1.如果父类没有空参构造方法,只有带参构造方法,会出现什么现象?
2.如何解决父类没有空参构造方法的问题?
3.能不能在构造方法中同时调用this()和super()?
解决方案:
子类通过super,手动调用父类的带参构造方法
子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法(不推荐)
注意事项:
this(…)和super(…) 必须放在构造方法的第一行有效语句,并且二者不能共存
如果this和super共存,就意味着子类对象有两个爹,这是不允许的。
//案例演示:
class Fu{
private String name;
public Fu(String name) {
this.name = name;
}
}
public class Zi extends Fu{
private int age;
private String sex;
public Zi(int age) {
//1.使用super手动调用父类的有参构造
super(“老王”);//得到一个父类对象
// this(“人妖”)
this.age = age;
}
public Zi(String sex) {
//super();//得到一个父类对象
this(23);
this.sex = sex;
}
}
单例模式种类
饿汉单例模式
定义对象属性时就创建对象
懒汉单例模式
定义对象属性时不创建对象,而是在调用获取对象的方法时才去创建对象
设计步骤
将类的构造器私有,避免外界利用构造器随意创建该类对象
在类中定义一个属性,属性类型就是该类自己
定义一个方法,用于返回该类唯一的对象
如果是饿汉式,在定义属性的时候,就创建对象给属性初始化
如果是懒汉式,在定义属性的时候不创建对象,把创建对象操作放到获取该类唯一对象的方法中
继承
请问,在1954年以前,有没有王思聪这个富二代?
问题:



