Java代码块和继承

一.代码块 代码块分为四种，分别是局部代码块、构造代码块、静态代码块和同步代码块。 同步代码块将在后⾯面的多线程中讲到，在此不不做赘述。

1.局部代码块 书写位置:⽅方法中 {代码}。 作⽤用:限制变量量的作⽤用域。
2.构造代码块
书写位置:类中 ⽅方法外。 调⽤用: 1.创建对象时系统⾃自动调⽤用。
2.在构造⽅方法调⽤用之前 构造代码块被调⽤用。 作⽤用:当你想每⼀一个对象创建出来时执⾏行行某些⽅方法， 可以在构造代码块中调⽤用。
(实际上利利⽤用了了特点 创建对象就会执⾏行行构造代码块)
3.静态代码块(使⽤用static修饰的代码块) 书写位置:类中 ⽅方法外
调⽤用:
1.随着类的加载⽽而调⽤用(和对象没关系)。 2.只加载⼀一次。 3.加载类到⽅方法区时系统⾃自动调⽤用。 作⽤用:加载驱动程序,只加载⼀一次(jdbc)。

public class CodeBlock{
static { System.out.println("我是main的静态代码块");
}
public static void main(String[] args) { // {
// System.out.println("我就是局部代码块"); // }
Person p = new Person(); }
}

 class Person{ String name;
public Person() { System.out.println("⽆无参构造");
}
public Person(String name) {
this.name =name;
System.out.println("有参构造"); }
public void sayHi() { System.out.println(name);
} {
System.out.println("我是构造代码块"); }
//静态代码块 static {
System.out.println("我是静态代码块"); }
}

二.继承 ⾯面向对象的特点有封装、继承与多态。今天我就继承来给⼤大家做⼀一下详细的介 绍。

继承的特点:
1.继承链
2.继承有传递性
3.继承属性和⾏行行为 4.建⽴立类与类之间的关系(继承关系) 注意:必须要符合⽣生活逻辑
继承优点: 1.减少代码量量 2.提⾼高⼯工作效率 3.增强代码的复⽤用性
继承弊端: ⾼高内聚:指⼀一个类的内部⽅方法的联系程度 低耦合:类与类之间尽量量减少联系 设计模式基本都是为了了解耦(降低耦合度)

写法
关键字 extends
⼦子类 extends ⽗父类 关于继承的简单代码:

public static void main(String[] args) {
Cat c1 = new Cat(); c1.name = "⼩小⽩白"; c1.age = 2; c1.sayHi();
} }
class Animial{ String name;
int age;
public void sayHi() { System.out.println(name + " " + age);
} }
class Cat extends Animial{ public void eat() {
System.out.println("fish"); }
}
class Dog extends Animial{
public void eat() { System.out.println("bone");
} ```
java中的继承(类和类之间的继承关系) 只允许单继承， 多继承体现在接⼝口。
Java中 允许 多层继承，也就是继承链。
⼩小技巧:
共有的⽅方法 ⼀一般使⽤用继承链中顶端的类。 特有的⽅方法 ⼀一般使⽤用继承链中底端的类。

 ```
public static void main(String[] args) {
//java中所有的类 如果没写继承哪个类 //默认继承object类
//object类 是所有类的基类 //直接打印对象 实际上调⽤用了了 //object类中的 toString()⽅方法
DemoA a =new DemoA();
System.out.println(a); }
class DemoA{ String name;
public void sayHi() { System.out.println(name);
} }
class DemoB extends DemoA{
}
class DemoC extends DemoB{
String gender; }

继承中的构造⽅方法
注意:构造⽅方法不不能继承
为什什么会调⽤用⽗父类的⽆无参构造⽅方法? 这保证继承的完整性，创建⼦子类对象时，为了了保证继承的完整性，
会默认调⽤用⽗父类的⽆无参构造⽅方法。

public class SimpleExample {
public static void main(String[] args) {
} }
Son son1 = new Son();
Son son2 = new Son("smile");

 class Father{
String name; public Father() {
super();//表示Father的⽗父类object类的对象
System.out.println("我是Father类的⽆无参构造⽅方法"); }
public Father(String name) { System.out.println("我是Father类的有参构造⽅方法");
}
public void sayHi() {
System.out.println(name); }
}
class Son extends Father{
public Son() { //系统会在⼦子类的⽆无参构造⽅方法的第⼀一⾏行行 super();//调⽤用⽗父类的⽆无参构造⽅方法 System.out.println("我是Son类的⽆无参构造⽅方法");
}
public Son(String name) {
super();
System.out.println("我是Son类的有参构造⽅方法"); }
} ```
super 和 this
this:类中表示本类的对象
继承中 this.属性 系统会先从本类中寻找该属性，找到就输出。 没找到，就去⽗父类中找，都没找到就报错。
super: 在⼦子类中 表示的是 ⽗父类对象 super: 也可以调⽤用⽗父类中的⽅方法

public class SimpleExample {
public static void main(String[] args) { TestB b = new TestB();
b.fun();
}

}
class TestA{
int num1 =10;
int num2 =20; public void haha() {
System.out.println(“smile”); }
}
class TestB extends TestA{
int num2 =30;
public void fun() { System.out.println(this.num1); System.out.println(this.num2); //这⾥里里super表示⽗父类对象 System.out.println(super.num2); System.out.println(super.num1); super.haha();
this.haha(); }
}

* ⽅方法的重载(overload)
* 前提:⽅方法都在⼀一个类中可以使⽤用重载。
* 当⽅方法的功能相同但内部实现不不同，可以使⽤用重载。 * ⽅方法的重写(override)
* 前提:类与类之间必须建⽴立继承关系。
* 作⽤用:相当于对原⽅方法功能上的⼀一个提升。
* 写法:⽅方法和⽗父类的完全⼀一致，才是⽅方法的重写。

public class SimpleExample {
public static void main(String[] args) {
IOS8 ios8 =new IOS8();
ios8.siri();
//意愿:直接输出对象的时候 //希望可以把对象的所有成员变量量打印出来
}

}
class Test1{
public void fun() { System.out.println(“我是Test1fun”);
} }
class Test2 extends Test1{ //重写fun⽅方法
public void fun() { //可以在重写的⽅方法中调⽤用⽗父类的原⽅方法 //可以让功能进⾏行行升级 System.out.println(“我是Test2fun”);
} }
class IOS7{
public void siri() {
System.out.println(“I can speak English”); }
}
class IOS8 extends IOS7{
//注解 标识下⾯面的⽅方法 是重写⽗父类的⽅方法 //重写object类中 tostring⽅方法
//可以代替之前的 介绍⾃自⼰己的⽅方法 来输出对象的所有属性 @Override
public void siri() {
super.siri();
System.out.println(“我也会说中⽂文”); }
}

1.修饰变量量时，变量量不不能更更改(相当于把变量量变成了了常量量)。 2.修饰⽅方法时，⽅方法不不能被重写。 3.修饰类时，该类不不能被继承。

public class SimpleExample {
public static void main(String[] args) { // final int a = 10;
// a = 15;

//final修饰引⽤用数据类型 //不不能修改地址(对象的属性 随便便改)
final Test3 t1 = new Test3(); t1.name = “haha”;
t1.name = “heiheihei”;
//t1 = new Test3();
}
}
class Test3{
//静态常量量
//命名规范 所有单词使⽤用⼤大写 多个单词⽤用下划线链接 //⽆无效值
public final int MAX_VALUE ;
String name;
//可以使⽤用构造⽅方法 或者构造代码块 对常量量进⾏行行赋值
public Test3() { MAX_VALUE = 10;
}
public void fun() {
} }
class Test4 extends Test3{ @Override
public void fun() {
super.fun(); }
} “`