1.代码块的概述和分类
1.代码块概述
在Java中，使用{}括起来的代码被称为代码块。
2.代码块分类
根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
3.常见代码块的应用
a:局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
b:构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
c:静态代码块
在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
局部代码块：
public class MyTest {
public static void main(String[] args) {
//代码块：就是被一对大括号，所扩起起来的代码。
//代码块，根据定义的位置不同，分为：局部代码块，构造代码块，静态代码块。同步代码块（后面讲）
//局部代码块，定义在方法中的代码块。
//构造代码块：定义在类中方法外，跟构造方法平级
//静态代码代码块：定义在类中方法外，用static所修饰的代码块、
int a=100;
{
//在方法中出现；限定变量生命周期，及早释放，提高内存利用率
int num=100;
System.out.println("这是局部代码块"+num);
System.out.println(a);
}
// System.out.println(num);
}
}
Student类:
public class Student {
static int num=100;
{
System.out.println("这是构造代码块");
}
static{
System.out.println("这是静态代码块");
System.out.println("静态代码块，比较常用，经常在静态代码块里面做一些初始化的准备工作。");
System.out.println(num);
}
public Student() {
System.out.println("这是空参构造");
}
}
测试类：
public class MyTest2 {
public static void main(String[] args) {
//创建对象时，会调用构造代码块，而且还是优先于构造方法执行。每次创建对象，都会调用构造代码块。
//静态代码块，随着类的加载而加载，优先于构造代码块执行。且只会执行一次。在静态代码块里面，只能访问静态成员。
Student student = new Student();
Student student1 = new Student();
}
}
2.代码块的面试题
看程序写结果
class Student {
static
System.out.println("Student 静态代码块"); //3
}
{
System.out.println("Student 构造代码块");//4 6
}
public Student() {
System.out.println("Student 构造方法");//5 7
}
}class StudentDemo {
static {
System.out.println("StudentDemo的静态代码块"); //1
}
public static void main(String[] args) {
System.out.println("我是main方法"); //2
Student s1 = new Student();
Student s2 = new Student();
}
}
3.继承的引入和概述
1.继承概述
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
2.继承格式
通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
4.继承案例演示以及继承的好处和弊端
1.需求：
Dog类和Cat类和Animal类。
定义两个功能(吃饭，睡觉)
2.案例演示
使用继承前
3.案例演示
使用继承后
4.继承的好处
a:提高了代码的复用性
b:提高了代码的维护性
c:让类与类之间产生了关系，是多态的前提
5.继承的弊端
类的耦合性增强了。
开发的原则：高内聚，低耦合。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力
Animal类：
public class Animal {
String name;
int age;
public void eat() {
System.out.println("吃饭饭55555555555555555555555");
}
public void sleep() {
System.out.println("睡觉");
}
Dog类：
public class Dog extends Animal{
public void lookDoor(){
System.out.println("看门");
}
}Cat类：
public class Cat extends Animal{
public void catchMouse(){
System.out.println("抓老鼠");
}
}测试类：
public class MyTest {
public static void main(String[] args) {
//面向对象的三大特征：封装（class） 继承 多态
//生活中的继承：儿子可以继承老子的财产。
//Java中的继承 ：子类可以继承父类的成员。
//可以使用 extends 关键字，可以让类和类之间形成父子关系。
//继承的好处：可以提高代码的复用性和维护性。
//继承的思想：把多个子类的共性内容，向上抽取到父类当中，以实现代码的复用性和维护性。
//继承的弊端：让类和类之间产生了关系，增加了耦合性。
//软件设计原则中：高内聚（某个事物独立完成功能），低耦合
Cat cat = new Cat();
cat.name="汤姆";
cat.age=15;
System.out.println(cat.name);
System.out.println(cat.age);
cat.eat();
cat.sleep();
cat.catchMouse();
System.out.println("====================================");
Dog dog = new Dog();
dog.name="旺财";
dog.age=5;
System.out.println(dog.name);
System.out.println(dog.age);
dog.sleep();
dog.eat();
dog.lookDoor();
}
}
5.Java中类的继承特点
1.Java中类的继承特点
a:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,...
b:Java支持多层继承(继承体系)
2.案例演示
Java中类的继承特点
6.继承的注意事项和什么时候使用继承
1.继承的注意事项
a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
c:不要为了部分功能而去继承
2.什么时候使用继承
继承其实体现的是一种关系："is a" .
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
public class MyTest {
public static void main(String[] args) {
//继承的注意事项；
//1.在Java中，只支持单继承，一个子类只能有一个父类，不能有多个父类，但是支持多层继承。
//Object 是所有类的顶层父类，所有类都是直接或间接继承自他。
//2. 构造方法不参与继承。当我们创建子类对象时，会先调用父类的构造方法，来完成父类数据的初始化。
//3. 父类私有的成员，子类不能继承。
Zi zi = new Zi();
System.out.println(zi.a);
System.out.println(zi.b);
//zi.fu();
}
}
class A extends Object{
int a=100;
private int bb=20;
}
class Fu extends A{
int b=20;
private double cc=3.14;
private void fu(){
}
}
class Zi extends Fu{
} 
7.继承中成员变量的关系
1.子类中的成员变量和父类中的成员变量名称不一样
2.子类中的成员变量和父类中的成员变量名称一样
在子类中访问一个变量的查找顺序("就近原则")
a: 在子类的方法的局部范围找,有就使用
b: 在子类的成员范围找,有就使用
c: 在父类的成员范围找,有就使用
d:如果还找不到,就报错
8.this和super的区别和应用
1.通过问题引出super
子类局部范围访问父类成员变量
2.说说this和super的区别
this 代表的是本类对象的引用
super 代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)
3.this和super的使用
a:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
b:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
c:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
练习：
public class MyTest {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show(5);
}
}
class Fu{
int num=100;
}
class Zi extends Fu{
int num=20;
public void show(int num){
System.out.println(num); //5
System.out.println(this.num); //20
System.out.println(super.num); //100
}
}Father类：
public class Father {
int num = 3000;
double aa =6.999;
boolean flag=true;
public void show() {
System.out.println("父类的show方法");
}
public void hehe() {
System.out.println("父类的hehe方法");
}
}Son类：
public class Son extends Father {
int num=100;
double aa=3.14;
char ch='a';
public void ziShow(int num){
/*
* 变量的访问原则：遵循就近原则，先在局部范围找（方法发内，以及形参） 如果找不到，就去本类的成员范围找（成员变量）
* 如果本类成员范围没找到，再去父类成员范围找，找到就使用，再找不到就报错。
*
* 当局部变量，本类成员变量，父类成员变量重名了，你可以使用 this super 来区分。
*
*
* */
System.out.println("子类的show方法");
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
System.out.println(aa);
System.out.println(super.aa);
System.out.println(this.aa);
System.out.println(flag);
System.out.println(super.flag);
System.out.println(this.flag);
System.out.println(ch);
}
public void haha(){
this.show(); //父类的这个show()方法被你继承了，相当于是你的了，所以前面加this也可以。
super.show(); //调用父类的方法
this.hh(); //调用本类方法
}
public void hh(){
System.out.println("hhhhhhhh");
}
}测试类：
public class MyTest {
public static void main(String[] args) {
//this 和 super
//super:代表父类空间的一个标识，你可以认为是父类的一个引用，使用它可以访问父类的数据。
//this:代表本类的一个引用，你使用this，那访问的就是本类的数据。
//访问成员变量
//this.成员变量 this.num
//super.成员变量 super.num
//访问成员方法：
// this.成员方法名() this.show()
// super.成员方法名() super.show()
// 访问构造方法
// this()
// super()
Son son = new Son();
son.ziShow(20);
son.haha();
}
}
9.继承中构造方法的关系
1.案例演示
子类中所有的构造方法默认都会访问父类中空参数的构造方法
2.为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
其实：
每一个构造方法的第一条语句默认都是：super()
Object类是父类。
public class MyTest {
public static void main(String[] args) {
//Father father = new Father();
//当我创建子类对象时，为什么会去先调用父类的空参构造方法，为什么？
/*
* 因为子类继承了父类，那也就是说，子类继承了父类的数据，甚至还有去使用父类的数据，
* 所以当我们创建子类对象时，应该先完成父类数据的初始化，那么子类才能继承父类的数据和使用父类的数据。
* 既然你要先完成父类数据的初始化，那肯定先要调用父类的构造方法，才能完成父类数据的初始化。
*
* */
Son son = new Son();
}
}
class Father{
int num=100;
public Father() {
System.out.println("Father父类的空参构造执行了");
}
}
class Son extends Father{
int s=20;
public Son() {
super();
System.out.println("son的空参构造执行了"+num+"==="+s);
}
} 
10.继承中构造方法的注意事项
1.案例演示
父类没有无参构造方法,子类怎么办?
a: 在父类中添加一个无参的构造方法
b:子类通过super去显示调用父类其他的带参的构造方法
c:子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造
2.注意事项
super(…)或者this(….)必须出现在第一条语句上
public class MyTest {
public static void main(String[] args) {
//当我创建子类对象时，为什么会去先调用父类的空参构造方法，为什么？
/*
* 因为子类继承了父类，那也就是说，子类继承了父类的数据，甚至还有去使用父类的数据，
* 所以当我们创建子类对象时，应该先完成父类数据的初始化，那么子类才能继承父类的数据和使用父类的数据。
* 既然你要先完成父类数据的初始化，那肯定先要调用父类的构造方法，才能完成父类数据的初始化。
* 怎么去调用的父类的构造方法呢？其实在每个类的构造方法前面第一行，有一条默认语句 super() 他就去调用父类的空参构造
*
* */
Zi zi = new Zi();
/*
*
* 如果说父类没有提供空参构造呢？
* //1. 你自己手动提供一个空参构造。
* //2. 可以调用父类有参构造方法。
* */
}
}
class Fu extends Object{
int num=200;
/*
public Fu() {
super();
System.out.println("父类的构造方法调用了");
}
*/
public Fu(int num){
System.out.println("父类的构造方法调用了");
System.out.println(num);
}
}
class Zi extends Fu{
int aa=20;
public Zi() {
//super();
//super(10); //调用父类有参构造
this(20); //调用本类的有参构造
System.out.println("子类的构造方法调用了");
}
public Zi(int num){
super(num);
System.out.println("子类的有参构造方法调用了");
}
}
11.继承中的面试题
1.案例演示
看程序写结果1
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu"); //1
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi"); //2
}
public void show(){
int num = 30;
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(super.num); //10
}
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}2.案例演示
看程序写结果2
class Fu {
static {
System.out.println("静态代码块Fu"); // 1
}{
System.out.println("构造代码块Fu"); //3
}public Fu() {
System.out.println("构造方法Fu"); //4
}
}class Zi extends Fu {
static {
System.out.println("静态代码块Zi");//2
}{
System.out.println("构造代码块Zi"); //5
}public Zi() {
super();
System.out.println("构造方法Zi"); //6
}
}
class Test{
public static void main(String[] args){
Zi z = new Zi(); //请问执行结果。
}
}
12.继承中成员方法关系
A:案例演示
a:当子类的方法名和父类的方法名不一样的时候
b:当子类的方法名和父类的方法名一样的时候
通过子类调用方法:
a: 先查找子类中有没有该方法,如果有就使用
b: 在看父类中有没有该方法,有就使用
c: 如果没有就报错
13.方法重写概述及其应用
1.什么是方法重写
子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。
2. Override和Overload的区别?Overload能改变返回值类型吗?
3.方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
4.案例演示
a:定义一个手机类。
b:通过研究，我发明了一个新手机，这个手机的作用是既可以语音通话，又可以视频通话。
Phone类：
public class Phone {
public void call(){
System.out.println("语音通话");
}
}
IPhone类：
public class IPhone extends Phone {
//方法重写：当子类出现和父类一模一样的方法（返回值类型，方法名，形参一样），就会发生子类方法，覆盖父类的方法的这种现象。
//为什么要有方法重写的这种机制？因为有可能子类对父类的方法实现，不满意，想要按照自己的逻辑进行实现，那么就可以通过方法重写来覆盖父类的方法。
//ctrl+O可以快速重写父类方法
@Override//注解： 可以检测该方法是不是重写父类的
public void call() {
super.call(); //继续沿用父类的功能
System.out.println("视频通话");
}
}测试类：
public class MyTest {
public static void main(String[] args) {
IPhone iPhone = new IPhone();
iPhone.call();
}
}
14.方法重写的注意事项
1.方法重写注意事项
a:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
b:子类重写父类方法时，访问权限不能更低,最好就一致
c:父类静态方法，不参与重写
子类重写父类方法的时候，最好声明一模一样。
2.案例演示
方法重写注意事项
public class MyTest {
public static void main(String[] args) {
//方法重写的注意事项：
//1.子类在重写父类的方法时，方法的权限修饰符，不能比父类的低，要比父类的高或一样。
//2. 父类私有的方法，子类不能重写，因为，私有的方法子类都不能继承，何谈重写。
//3. 构造方法，不能重写，
//4. 静态方法也不算重写
Zi zi = new Zi();
zi.hehe();
Zi.hehe();
Fu.hehe();
}
}
class Fu {
void show() {
}
public static void hehe(){
System.out.println("父类静态方法");
}
}
class Zi extends Fu {
@Override
public void show() {
}
//@Override
public static void hehe() {
System.out.println("子类静态方法");
}
} 
15.使用继承前的学生和老师案例
使用继承后的学生和老师案例
人类：
public class Person {
String name;
int age;
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}学生类：
public class Student extends Person{
@Override
public void eat() {
System.out.println("学生爱吃麻辣烫");
}
@Override
public void sleep() {
System.out.println("学生喜欢上课睡觉");
}
public void homeWrok(){
System.out.println("做作业");
}
}老师类：
public class Teacher extends Person{
@Override
public void eat() {
System.out.println("老师爱吃燃面");
}
@Override
public void sleep() {
System.out.println("老师晚上睡觉");
}
public void teach(){
System.out.println("教书");
}
}
测试类：
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.name="张三";
student.age=20;
System.out.println(student.name);
System.out.println(student.age);
student.sleep();
student.eat();
student.homeWrok();
System.out.println("===============================================");
Teacher teacher = new Teacher();
teacher.name = "老李";
teacher.age=30;
System.out.println(teacher.name);
System.out.println(teacher.age);
teacher.eat();
teacher.sleep();
teacher.teach();
}
}
16.final关键字概述
1.为什么会有final
由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: final
2.final概述
final关键字是最终的意思，可以修饰类，变量，成员方法。
17.final关键字修饰类,方法以及变量的特点
1.final修饰特点
修饰类: 被修饰类不能被继承
修饰方法: 被修饰的方法不能被重写
修饰变量: 被修饰的变量不能被重新赋值,因为这个量其实是一个常量
2.案例演示
final修饰特点
18.final关键字修饰局部变量
基本类型，是值不能被改变
引用类型，是地址值不能被改变
public class MyTest {
public static final int A=100; //公共的静态常量
public static void main(String[] args) {
// final 最终的，可以修饰变量和方法以及类
//1. final 修饰变量，此变量为常量 常量名大写。
final int NUM=20;
System.out.println(MyTest.A);
//2.final 修饰方法此方法不能被重写,子类可以继承final 方法，不能重写。
Zi zi = new Zi();
zi.show();
//3. final 修饰类，此类不能被继承
final int a=20;
//final 修饰基本数据类型的变量，指的是值不能被改变。
final Zi zi1 = new Zi();
//zi1=new Zi();
//final 修饰引用数据类型的变量，指的是地址值不能被改变。
}
}
class Fu{
public final void show(){}
}
class Zi extends Fu{
//public final void show()
}
300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
