Java-代码块、继承、super 和this

代码块

1.局部代码块

 * 书写位置：方法中

 * 作用：限制作用域

 * 2.构造代码块

 * 书写位置：类中 方法外

 * 代码的执行顺序:

 * 1.系统调用的

 * 2.只要创建对象 就会调用

 * 3.构造代码块 在 构造方法 之前被调用

 * 作用：当你有方法 需要每一个对象都调用的时候

 * 可以将这个方法 在构造方法之前被调用（不常用）

 * 

 * 3.静态代码块

 * 使用关键词 static 修饰的代码块

 * 位置：类中 方法外

 * 调用顺序：

 * 1.随着类的加载而

 * 2.只加载一次

 * 3.在构造代码块之前执行

 * 应用场景：

 * 加载驱动（加载数据库驱动）

 * 4.同步代码块（多线程部分）

public static void main(String[] args) {
		//fun1();
		
		Person p1 = new Person();
		p1.name = "小明";
		p1.age = 18;
		p1.sayHi();
		
		Person p2 = new Person("小宇",20);
		p2.sayHi();
	}
	private static void fun1() {
		{
			//局部代码块 限制变量的作用域
			int num = 10;
		}
		//System.out.println(num);
	}
	}
class Person{
	String  name;
	int age;
	// 无参 和 有参构造方法
	public Person() {
		System.out.println("我是无参构造方法");
	}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	//介绍自己的方法
	public void sayHi() {
		System.out.println(name + "..." + age);
	}
	//吃
	public void eat() {
		System.out.println("吃饭");
	}
	//构造代码块
	{
		System.out.println("我是 构造代码块");
	}
	
	//静态代码块
	static {
		System.out.println("我是静态代码块");
	}
}

面向对象特征：封装 继承 多态

 * 继承：

 * 1.可以进行传递

 * 2.继承的是 属性 和 行为（不是全部）

 * 3.继承 建立 类与类之间的关系

 * 继承的好处：减少代码量 提高工作效率 增强 类与类直接关系

 * 

 * 继承的弊端：

 * 高内聚:希望一个类中 方法与方法之间联系加强

 * 低耦合:希望类与类之间 减少联系

public static void main(String[] args) {
		// 创建一只猫
		  Cat cat = new Cat();
		    cat.color = "蓝色";
		    cat.name = "汤姆";
		    cat.sayHi();
		// 创建一只狗
		    Dog dog = new Dog();
		    dog.color = "黑加红";
		    dog.name = "藏獒";
		    dog.sayHi();
		    
	}
}

class Animail{
	String name;
	String color;
	// 介绍自己的方法
	void sayHi() {
		System.out.println(name + "..." + color);
	}
}
class Cat extends Animail {
	public void speak() {
		System.out.println("喵喵喵");
	}
}

class Dog extends Animail {
	public void speak() {
		System.out.println("汪汪汪");
	}
}

java中 只允许单继承（通过接口实现多继承）

 * Java中 还允许 多层继承（继承连）A -> B -> C

 * 

 * 当你想只使用共有的方法和属性 使用哪个类的对象？

 * 一般选择 使用继承链 最顶端的类

 * 当你想使用共有的方法的时候 使用哪个类的对象？

 * 一般选择 使用继承链 最末端的类

 * 

 * 如果一个类没有写继承 那么这个类 默认继承 object类（基类）

public static void main(String[] args) {
		DemoA a = new DemoA();
		//直接打印对象的时候
		//相当于调用了object类中 tostring方法
		//tostring方法的作用：
		System.out.println(a.toString());
	}
}

class DemoA extends Object {
	String name;
	public void sayHi() {
		System.out.println(name);
	}
}
class DemoB extends DemoA{
	
}
class DemoC extends DemoB{
	String sex;
}

继承中的 构造方法

 * 注意：构造方法是不能被继承的

 * 当曾经子类对象的时候 为了保证继承的完整性

 * （不管你在创建子类对象的时候 使用的是 无参还是有参构造）

 * 系统会默认帮你调用 父类中的 无参构造方法

public static void main(String[] args) {
		Son son = new Son();
		System.out.println("------------------");
		Son son1 = new Son("天明");
	}
}

class Father{
	String name;
	public Father() {
		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

 * super 在子类中代表的是父类的对象

 * this 在子类 可以调用子类的属性 和 方法

 * （现在当前类中找这个属性,没找到的话会去父类中找）

 * this和super的区别:

 * this在类中代表着本类的对象(当前类的对象),

 * super在类中代表着父类的对象

class TestA{
	int num1 = 10;
	int num2 = 20;
	
	public void fun() {
		System.out.println("我是父类的方法");
	}
}
class TestB extends TestA{
	int num2 = 30;
	
	public void print() {
		System.out.println(this.num1);
		System.out.println(this.num2);
		//直接调用父类的属性 使用super关键字
		System.out.println(super.num2);
		//也可以调用父类的方法
		
	}
}