08.01_代码块的概述和分类(面试时会问，开发时不用或很少用)
-
A:代码块概述
- 在Java中，使用{}括起来的代码称为代码块
-
B:代码块分类
- 根据其位置和声明不同，可分为局部代码块，构造代码块，静态代码块，同步代码块（多线程时会讲）。
-
C:常见代码块应用
-
a:局部代码块
- 在方法中出现；限定了变量的生命周期，及早释放，提高内存使用率。
- 程序段
class Demo1_Code { public static void main(String[] args) { { int x = 10; } System.out.println(x); //会报错，上述为局部代码块，执行完成后，x从内存中被释放 } } -
b:构造代码块（初始化块）
- 在类中方法外出现，多个构造方法中相同的代码存放在一起，每次调用构造都执行，并且在构造方法前执行。
- 程序段
class Demo1_Code { public static void main(String[] args) { Student s1 = new Student(); System.out.println("-----------"); Student s2 = new Student("张三",23); System.out.println("-----------"); Student s3 = new Student("李四",24); System.out.println("-----------"); /* 输出： 学生学习 空参构造 ----------- 学生学习 有参构造 ----------- 学生学习 有参构造 ----------- */ } } class Student { private String name; private int age; public Student() { System.out.println("空参构造"); } public Student(String name,int age) { this.name = name; this.age = age; System.out.println("有参构造"); } //构造代码块：每创建一次对象就会执行一次，优先于构造函数存在 { study(); } public void study() { System.out.println("学生学习"); } } -
c:静态代码块
- 在类中方法外出现，加了static修饰
- 在类中方法外出现，并加上了static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
- 程序段：
class Demo1_Code { public static void main(String[] args) { Student s1 = new Student(); System.out.println("-----------"); Student s2 = new Student("张三",23); System.out.println("-----------"); Student s3 = new Student("李四",24); System.out.println("-----------"); /* 输出： 我是静态代码块 学生学习 空参构造 ----------- 学生学习 有参构造 ----------- 学生学习 有参构造 ----------- */ } } class Student { private String name; private int age; public Student() { System.out.println("空参构造"); } public Student(String name,int age) { this.name = name; this.age = age; System.out.println("有参构造"); } //构造代码块：每创建一次对象就会执行一次，优先于构造函数存在 { study(); } public void study() { System.out.println("学生学习"); } //随着类的加载而加载，且只执行一次 //作用：用来给类进行初始化，一般用来加载驱动 //静态代码块优先于主方法(main)进行 static { System.out.println("我是静态代码块"); } }
-
08.02_代码块面试题
- A:写出下面程序的输出结果
class Demo1_Code {
static {
System.out.println("Demo1_Student 静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
class Student {
static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法"); }
}
输出如下：
Demo1_Student 静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
- B:代码块执行顺序和次数
- 测试类静态代码块(只执行1次)————测试类主方法(只执行1次)————基本类里的静态代码块(只执行1次)————基本类的构造代码块(每创建一次对象执行1次)————基本类的构造方法(每创建一次对象执行1次)。
08.03_继承案例演示
- A:继承(extends)
- 让类与类之间产生关系，子父类关系。
- B:案例演示
- 动物类，猫类，狗类
- 定义两个属性(颜色，腿的个数)和两个功能(吃饭，睡觉)
- C:案例演示——继承前
class Demo1_Extends {
public static void main(String[] args) {
}
}
//猫类
class cat {
String color;
int leg;
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
//狗类
class Dog {
String color;
int leg;
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
- D:案例演示——继承后
class Demo1_Extends {
public static void main(String[] args) {
Cat c = new Cat();
c.color = "花";
c.leg = 4;
c.eat();
c.sleep();
System.out.println(c.leg + "..." + c.color);
}
}
//动物类
class Animal {
String color;
int leg;
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
//猫类
class Cat extends Animal{
}
//狗类
class Dog extends Animal{
}
/*
extends是继承的意思，为java里的关键字
Animal是父类
Cat和Dog是子类
*/
08.04_继承的好处和弊端
- A:好处
- a:提高了代码的复用性
- b:提高了代码的维护性
- c:让类与类之间产生了关系，是多态的前提。
- B:弊端
- 类的耦合性增强了
- 开发的原则：高内聚，低耦合
- 耦合：类与类之间的关系
- 内聚：就是自己完成某件事的能力
08.05_Java中类的继承特点
- A:Java中类的继承特点
- a:Java只支持单继承，不支持多继承(一个儿子只能有一个爹)
- 因为多继承有安全隐患。比如，两个类中有同名方法，如果第三个类继承了，那么就不知道该调用哪种方法。
- b:Java支持多层继承(继承体系，儿子继承父亲，父亲继承爷爷)
- 如果想用这个体系所有的功能，用最底层的类创建对象
- 如果想看这个体系的共性功能，看最顶层的类。
- a:Java只支持单继承，不支持多继承(一个儿子只能有一个爹)
- B:案例演示
class Demo1_Extends {
public static void main(String[] args) {
}
}
//最顶层的类，表示类的共性
class DemoA {
public void show() {
System.out.println("DemoA");
}
}
class DemoB extends DemoA{
public void method() {
System.out.println("DemoB");
}
}
//最底层的类，含有该类的所有功能
class DemoC extends DemoB{
public void print() {
System.out.println("DemoC");
}
}
08.06_继承的注意事项和什么时候使用继承
- A:注意事项
- a:子类只能继承父类所有非私有成员
- b:子类不能继承父类的构造方法，但可以通过super关键字取访问父类中的构造方法。
- c:不要为了部分功能而去继承
- B:什么时候使用继承
- 继承体现的是一种关系
- 采用假设法
- 如果有两个类A,B，只要他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
08.07_继承中成员变量的关系
- A:案例演示
- a:不同名的变量
- b:同名的变量
- 子类和父类出现同名的变量只在讲课的例子中有，在开发中是不会出现这样情况的。因为子类继承父类即时为了使用父类的成员，如果定义了同名的成员变量就没有意义了。
- 程序段
class Demo1_Extends { public static void main(String[] args) { Son s = new Son(); s.print(); } } class Father { int num1 = 10; int num2 = 30; } class Son extends Father { int num2 = 20; public void print() { System.out.println(num1); //10 System.out.println(num2); //20.就近原则，子类有就不用父类了 } }
08.08_this和super的区别和应用
- A:this和super都代表什么？
- this:代表当前对象的引用，谁来调用我，我就代表谁
- super:代表当前对象父类的引用
- B:this和super的使用区别
- a:调用成员变量
- this.成员变量 调用本类的成员变量，也可以调用父类的成员变量
- super.成员变量 调用父类的成员变量
- b:调用构造方法
- this(…) 调用本类的构造方法
- super(…) 调用父类的构造方法
- c:调用成员方法
- this.成员方法 调用本类的成员方法，也可以调用父类的成员方法
- super.成员方法 调用父类的成员方法
- a:调用成员变量
- C:B中a情况的案例演示
class Demo1_Extends {
public static void main(String[] args) {
Son s = new Son();
s.print();
}
}
class Father {
int num1 = 10;
int num2 = 30;
}
class Son extends Father {
int num2 = 20;
public void print() {
System.out.println(this.num1); //调用本类的num1
System.out.println(this.num2); //调用本类的num2,如果本类中没有num2，则调用的就是父类里的num2
System.out.println(super.num2); //调用父类的num2
}
}
08.09_继承中构造方法的关系
- A:案例演示
- 子类中所有的构造方法默认都会访问父类中的空参构造方法。
- B:程序段
class Demo1_Extends {
public static void main(String[] args) {
Son s = new Son();
/*
输出:
Father的构造方法
Son的构造方法
*/
}
}
class Father {
public Father() {
System.out.println("Father的构造方法");
}
}
class Son extends Father {
public Son() {
super(); //这是一条语句，如果不写，系统会默认加上，用来访问父类中的空参构造
System.out.println("Son的构造方法");
}
}
- B:为什么呢？
- 因为子类会继承父类中的数据，可能还会使用父类的数据
- 所以，子类在初始化之前，一定要先完成父类数据的初始化
- 其实：
- 每一个构造方法的第一条语句默认都是：super();
08.10_继承中构造方法的注意事项
- A:注意事项
- 父类中没有无参数构造方法，子类怎么办？
- super()解决
- this()解决
- super(…)或者this(…)必须出现在构造方法的第一条语句上。
- B:super()解决
class Demo1_Extends {
public static void main(String[] args) {
Son s1 = new Son();
System.out.println(s1.getName() + "..." + s1.getAge());
System.out.println("-----------");
Son s2 = new Son("张三",23);
System.out.println(s2.getName() + "..." + s2.getAge());
/*
输出:
Father 有参构造
Son 空参构造
李四...24
-----------
Father 有参构造
Son 有参构造
张三...23
*/
}
}
class Father {
private String name;
private int age;
//父类中无空参构造
/*public Father() {
System.out.println("Father 空参构造");
}*/
public Father(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Father 有参构造");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
class Son extends Father {
public Son() {
super("李四",24); //super(...)解决
System.out.println("Son 空参构造");
}
public Son(String name,int age) {
super(name,age);
System.out.println("Son 有参构造");
}
}
- C:this()解决
class Demo1_Extends {
public static void main(String[] args) {
Son s1 = new Son();
System.out.println(s1.getName() + "..." + s1.getAge());
System.out.println("-----------");
Son s2 = new Son("张三",23);
System.out.println(s2.getName() + "..." + s2.getAge());
/*
输出:
Father 有参构造
Son 有参构造
Son 空参构造
王五...25
-----------
Father 有参构造
Son 有参构造
张三...23
*/
}
}
class Father {
private String name;
private int age;
//父类中无空参构造
/*public Father() {
System.out.println("Father 空参构造");
}*/
public Father(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Father 有参构造");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
class Son extends Father {
public Son() {
this("王五",25); //this(...)解决
System.out.println("Son 空参构造");
}
public Son(String name,int age) {
super(name,age);
System.out.println("Son 有参构造");
}
}
08.11_继承中的面试题
- A:写结果
class Fu {
public int num = 10;
public Fu() {
System.out.println("fu");
}
}
class Zi extends Fu {
public int num = 20;
public Zi() { //这里隐藏了一句super();
System.out.println("zi");
}
public void show() {
int num = 30;
System.out.println(num); //就近原则
System.out.println(this.num); //本类里的num成员
System.out.println(super.num);//父类里的num成员
}
}
class Test1_Extends {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
输出
fu
zi
30
20
10
- B:写输出
class Fu {
static {
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu() {
System.out.println("构造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi() {
System.out.println("构造方法Zi");
}
}
class Test1_Extends {
public static void main(String[] args) {
Zi z = new Zi();
}
}
输出
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
08.12_继承中的成员方法关系
- A:不同名的方法
class Demo1_Extends {
public static void main(String[] args) {
Son s = new Son();
s.print(); //调用父类print方法
s.method(); //调用子类的method方法
}
}
class Father {
public void print() {
System.out.println("Fu print");
}
}
class Son extends Father {
public void method() {
System.out.println("Zi Method");
}
}
- B:重名的方法
class Demo1_Extends {
public static void main(String[] args) {
Son s = new Son();
s.print(); //子类的print方法
s.method(); //子类的method方法
}
}
class Father {
public void print() {
System.out.println("Fu print");
}
}
class Son extends Father {
public void method() {
System.out.println("Zi Method");
}
public void print() {
System.out.println("Zi print");
}
}
以上，子类和父类里都有print方法，那么称这种情况为方法重写，子类重写了父类的方法。
08.13_方法重写概述和应用
- A:什么是方法重写
- 子父类出现了一模一样的方法。
- B:方法重写的应用
- 当子类需要父类的功能，而功能主体子类有自己特定的内容时，可以重写父类中的方法。这样，既沿袭了父类的功能，又定义了子类特有的内容。
- C:案例演示
class Demo1_Phone {
public static void main(String[] args) {
Ios8 i = new Ios8();
i.siri();
i.call();
}
}
class Ios7 {
public void call() {
System.out.println("打电话");
}
public void siri() {
System.out.println("speak English");
}
}
class Ios8 extends Ios7 {
public void siri() { //方法重写
super.siri(); //如果想继续用父类里的siri方法，则可以通过super.来调用
System.out.println("说中文");
}
}
08.14_方法重写的注意事项
- A:方法重写的注意事项
- a:父类中的私有成员不能被重写
- 因为父类私有方法子类根本无法继承
- b:子类重写父类方法时，访问权限不能更低
- 最好就一致
- c:父类的静态方法，子类也必须通过静态方法进行重写
- 其实这个算不上方法重写，但是现象确实如此。至于为什么算不上方法重写，多态时会讲(静态只能覆盖静态)。
- d:子类重写父类方法的时候，最好声明一模一样
- a:父类中的私有成员不能被重写
08.15_方法重写vs方法重载
- A:Override和Overload的区别？
- Overlode可以改变返回值类型，只看参数列表
- 方法重写：子类中出现了和父类中一模一样的方法，与返回值类型有关，返回值类型是一致的(或者是子父类)
- 方法重载：本类中出现的方法名一样，参数列表不同，与返回值类型无关。
- 子类对象调用方法的时候：
- 先找子类本身，再找父类。
08.16_final关键字修饰类，方法以及变量的特点
- A:final修饰特点
- 修饰类：类不能被继承
- 格式：final class 类名
- 修饰变量：变量就变成了常量，只能被赋值一次
- 格式：public static final 常量名
- 修饰方法：方法不能被重写
- 格式：public final void 方法名
- 修饰类：类不能被继承
08.17_final关键字修饰局部变量
- A:案例演示
- 基本类型：是值不能被改变
- 引用类型：是地址值不能被改变，对象中的属性可以被改变
- B:程序段
class Demo1_Final {
public static void main(String[] args) {
//基本数据类型，是值不能被改变
/*final int num = 10;
num = 20;
System.out.println(num);*/
//引用数据类型，地址值不能被改变
/*final Person p = new Person();
p = new Person("李四",24);*/
//引用数据类型，对象里面的属性值可以被改变
final Person p = new Person();
p.setName("李四");
p.setAge(24);
System.out.println(p.getName() + "..." + p.getAge());
}
}
class Person {
private String name;
private int age;
public Person() {}
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
08.18_final修饰变量的初始化时机
- A:初始化时机
- 显示初始化
- 在对象构造完毕前即可
- B:案例演示
class Demo1_Final {
public static void main(String[] args) {
DemoF d = new DemoF();
d.print();
}
}
class DemoF {
//final int num = 10; //方法一：显示初始化，不能不赋值，因为成员变量的默认初始化值为无效值
//方法二：或者在对象构造完成前赋值，即通过构造方法进行初始化
final int num;
public DemoF() {
num = 10;
}
public void print() {
System.out.println(num);
}
}
8116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
