JAVA基础09

JAVA基础09

代码块

静态代码块 static{} 随着类的加载而运行

构造代码块 {} 随着对象的创建而运行

局部代码块 方法中{} 如果你的一个方法中有大量的只使用一次就不在使用的代码 那么我们可以使用局部代码块进行封装 封装完以后 一旦局部代码块执行完毕 那么这些变量或者其他的就会被立即释放

public class Demo1 {
	static{
		System.out.println("我是静态代码块");
	}
	{
		System.out.println("我是构造代码块");
	}
	public static void main(String[] args) {
		Demo1 demo1 = new Demo1();//构造代码块随着new对象而加载
	{
		System.out.println("我是局部代码块");
	}
}
}

final 关键字

final: 修饰符, 可以用来修饰 类, 方法, 变量

•  被final修饰的类不能被继承
  

•  被final修饰的方法不能被重写
  

•  被final修饰的变量值不能改变
  

•  final  修饰的变量一定要有初始值
  

•  final 修饰的引用数据数据: 地址值不能改变, 可以改变里面的属性值
  

•  一般我们在定义常量的时候,往往是final 和 static 一起使用
  

public class FinalDemo {
}
class Test{
	public static final double PI = 3.14;
public void test() {
}
}
class Test3{
	int a = 100;
}
class Test2 extends Test{
	final int a = 100;
	int b;
	final Test3 t = new Test3();
public void test() {
	t.a = 200;
}
}

形参和实参

形参: 定义方法时参数列表上的变量

• 实参: 调用方法时传进去的值
• 基本数据类型做参数,形参的改变不影响实参的值
• 引用数据类型做参数,形参的改变影响实参的值(String 和 包装类除外)

public class FinalDemo {
	public static void main(String[] args) {
		int a = 10;
		test(a);
		System.out.println(a); //11
		int[] arr = new int[] { 2 };
		test(arr);
		System.out.println(arr[0]); //10
	}
	public static void test(int a) {
		a++;
		System.out.println(a); //10
	}
	public static void test(int arr[]) {
		arr[0] = 10;
		System.out.println(arr[0]); //10
	}
}

继承

格式:

class 子类 extends 父类名{}

被继承的类: 叫做父类,基类或超类

继承的类: 子类或派生类

一个文件中定义多个类 :

只能有一个类使用public修饰,用public修饰的类必须和文件名相同

main方法也必须定义在这个类中

java 中的继承 只支持单继承,不支持多继承,但是支持多层继承

父类中的私有成员是不能够被继承的

构造方法不能被继承,因为构造方法名与类名相同.

Object: 万类之祖 : 如果一个类没有继承任何类,那么他默认继承自Object

继承中成员变量的关系

先去子类中找,再去父类中找,没有就报错

super关键字

super: (父类中的对象) 用于子类的成员和父类的成员重名是时

super 指代父类中的

this: (本类中的对象) 用于成员变量和局部变量重名时, this指代的是成员变量

在静态的方法中是不能使用this/super

调用成员:

​ this.成员(调用本类中的成员变量,成员方法)

​ super.成员(调用父类中的成员变量,成员方法)

调用构造方法:

​ this(参数); // 调用本类中的构造方法

​ super(参数); // 调用父类中的构造方法

this()和super()不能同时使用 因为他们都必须放在构造的第一行

class Person1 {
	String name;
	int age;
public void eat() {
	System.out.println("人类都需要吃饭");
}
}
class Student1 extends Person1 {
	String name;
	int id;
public void eat() {
	super.eat(); // 在子类的成员方法中使用super调用父类中的成员方法
	System.out.println(super.name + "学生喜欢吃肉");
}
}

class Person2 {
	String name;
	int age;
	public Person2(String sex) {
	}
}
class Student2 extends Person2 {
	public Student2() {
		super("1");
		System.out.println("因为父类中没有无参构造,我需要先调用父类中的有参构造");
	}
	public Student2(String study) {
		this();
		// super("1");
		System.out.println("因为父类中没有无参构造,我需要先调用父类中的有参构造或" + "调用本类中的无参构造(因为上面已经调过父类的构造方法),否则无法运行,但是this和super不能同时存在");
	}
}

继承中构造方法的关系

class A1{
    public A1(){
        System.out.println("我是A1");
    }
}
class B1 extends A1{
    public B1(){
        System.out.println("我是B1");
    }
}
class C1 extends B1{
    public C1(){
        System.out.println("我是C1");
    }
}
Main(){
    C1 c = new C1();
}

我是A1
我是B1
我是C1

继承中成员方法的关系

现在子类中找,子类中没有就去父类中找,在没有,就报错

方法的重载和方法的重写

方法的重载: overload: 一个类中可以存在多个名字相同的方法,但是必须保证参数的个数或类型不同,与返回值无关

方法的重写: override: 子类中出现了和父类中的 方法名,参数列表,返回值类型 都一样的(成员)方法,也叫做方法的覆写

多态

三个前提:

​ 有继承和实现关系

​ 父类的引用指向子类的对象

​ 方法的重写

两种调用

​ 同名的成员变量: 父类的

​ 同名的成员方法: 子类的

​ 无法调用子类中独有的属性和方法

​ 父类中独有: 父类的

二种转型

​ 向上转型: Person p = new Teacher();

​ 向下转型 Teacher t = (Teacher)p;

public class Demo6 {
	public static void main(String[] args) {
		Dog d = new Dog();
		setAnimal(d, "dog");
		Cat c = new Cat();
		setAnimal(c, "cat");
	}
	//创建一个动物的静态方法,给子类调用,使父类的引用指向子类的对象,
	public static void setAnimal(Animal a, String name) { //Animal a= new Dog;向下转型
		if (name.equals("dog")) {//判断是哪个动物类,使用父类的对象名,给其赋值
			a.age = 18;
			a.name = "大黄";
			a.eat();
			Dog dog = (Dog) a;//子类独有的参数调用,需要向下转型
			dog.sex = "公";
			a.eat();
			dog.lookdoor();
		} else if (name.equals("cat")) {
			a.age = 8;
			a.name = "小黄";
			a.eat();
			Cat cat = (Cat) a;
			cat.sex1 = "母";
			cat.eat();
			cat.sleep();
		}
	}
}
class Animal {
	String name;
	int age;
	public void eat() {
}
}
class Dog extends Animal {
	String sex;
	public void eat() {
		System.out.println(name + age + sex + "吃骨头");
	}
	public void lookdoor() {
		System.out.println(name + "看门");
	}
}
class Cat extends Animal {
	String sex1;
	public void eat() {
		System.out.println(name + age + sex1 + "猫吃鱼");
	}
	public void sleep() {
		System.out.println("猫不睡觉");
	}
}