代码块
在Java中，使用{}括起来的代码称为代码块
根据其位置和声明的不同，可以分为四种：
1.构造代码块：是在类中直接定义的，每次调用构造方法前执行，都会先执行构造代码块。
2.静态代码块：是在类中定义的，使用关键词 static 修饰的代码块，只加载一次，随着类的加载而加载，
在构造代码块之前执行
3.局部代码块：在方法内，局部位置，用于限定变量的生命周期
4.同步代码块：如果在代码块前加上 synchronized关键字，则此代码块就成为同步代码块。
举例：
public class Demo {
static {
System.out.println("我是main方法的静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main函数");
Test test1 = new Test();
Test test2 = new Test("小宝");
}
}
class Test{
String name;
public Test() {
System.out.println("我是Test类 无参构造方法");
}
public Test(String name) {
System.out.println("我是Test类 有参构造方法");
}
{
System.out.println("我是Test类 构造代码块");
}
static {
System.out.println("我是Test类 静态代码块");
}
}
输出结果：
我是main方法的静态代码块
我是main函数
我是Test类 静态代码块
我是Test类 构造代码块
我是Test类 无参构造方法
我是Test类 构造代码块
我是Test类 有参构造方法
继承
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为(并不是全部)。使用继承一定要符合逻辑。
public class Demo {
public static void main(String[] args) {
//创建一只猫
Cat cat = new Cat();
cat.name = "汤姆";
cat.color = "灰白色";
cat.say();
// 创建一只狗
Dog dog = new Dog();
dog.name = "日天";
dog.color = "棕色";
dog.say();
}
}
// 公共父类
class Animal{
String name;
String color;
public void say() {
System.out.println(name+".."+color);
}
}
//猫类 class Cat extends Animal{
public void speak() {
System.out.println("喵喵喵");
}
}
//狗类 class Dog extends Animal{
public void speak() {
System.out.println("汪汪汪");
}
}
注意：如果一个类没有写继承，那么这个类 默认继承 Object
public static void main(String[] args) {
DemoA a = new DemoA();
//当直接打印对象的时候
//相当于调用了 Object类中的 toString方法
System.out.println(a);
}
输出的是： 全类名@16进制的hashcode码
继承的特性
子类拥有父类非private的属性，方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
继承中的构造方法：
注意：构造方法是不能继承的
当创建子类对象的时候 是为了保证继承的完整性，
不管你使用的是 无参还是有参构造，系统会帮你调用父类中的无参构造方法。
public class Demo05 {
public static void main(String[] args) {
Son son1 = new Son();
System.out.println("-------------");
Son son2 = new Son("彭于晏");
}
}
class Father{
String name;
public Father() {
System.out.println("我是Father类的无参构造方法");
}
public Father(String name) {
this.name = name;
System.out.println("我是Father类的有参构造方法");
}
public void say() {
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 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字： 指向自己的引用。在子类可以调用子类的属性和方法，
当子类中没有这个属性或者方法的时候，就去父类中寻找 ，找到就用，没找到就报错
方法重载和方法重写
方法的重载（overload） 在一个类中进行
方法的重写（override） 至少两个类并且还有继承关系，相当于对父类的该方法进行升级
public class Demo {
public static void main(String[] args) {
TestD testD = new TestD();
testD.print();
}
}
class TestC{
public void print() {
System.out.println("我是C类的print方法");
}
}
class TestD extends TestC{
public void print() {
// 重写父类的方法时
// 调不调用父类的方法 根据你的需求而定
super.print();
System.out.println("我是D类的print方法");
}
}
class IOS7{
public void siri(){
System.out.println("说英文");
}
}
class IOS8 extends IOS7{
// 注解：标识这个方法是重写父类的方法
@Override
public void siri() {
super.siri();
System.out.println("说中文");
}
// 这个方法 一般用来输出本类中的属性
@Override
public String toString() {
// 调用的是父类方法
// 打印出来默认 全类名@16进制hashcode码
return "我就想看看属性";
}
}
关键字 final
1、final修饰的类不能被继承。
2、Sting就是一个被final修饰的类，我们只能用，不用继承。
3、final不仅可以修饰类，还可以修饰变量，被final修饰的变量就是一个常量，只能赋值一次。
4、修饰方法，方法不能被重写5、修饰引用数据类型 不能进行重新指向(地址不能改了) 对象中的属性不会影响修改
一般使用final的时候 会直接定义成静态常量，使用类名直接调用，常量命名规范 ，所有字母大写，多单词用下划线分开。
public static final int MAX_VALUE =10;