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("猫不睡觉"); } }