java 05

java 05 java 05

java 05JDK中的主要包导入类 import面向对象的三大特征继承Object类方法重写overridefinal关键字组合IDEA 快捷键equals方法的重写super

JDK中的主要包

java.lang:包含一些java语言的核心类

java.awt:包含了构成抽象窗口工具集

java.net：执行与网络相关的 *** 作的类

java.io：提供多个输入/输出功能的类

java.util：包含一些实用工具类

导入类 import

java中会默认导入java.lang包下的所有类，因为这些类我们可以直接使用

如果导入两个同名的类，只能用包名加类名来显示调用相关类

import.java.util.*:导入该包下的所有类，会降低编译速度，但不会降低运行速度

静态导入：其作用是用于导入指定类的静态属性和静态方法

面向对象的三大特征

继承

封装

多态

继承

作用：

代码复用，更加容易实现类的扩展

方便建模

实现：extends子类是父类的扩展

public class TestExtends {
    public static void main(String[] args) {
        Student s1 = new Student("x",160,"java");
        System.out.println(s1 instanceof Student);//true
        System.out.println(s1 instanceof Person );//true
    }
}
class Person {
    String name;
    int height;
    public void rest(){
        System.out.println("休息！");
    }
}
class Student extends Person{
//    String name;
//    int height;
    String major;
//    public void rest(){
//        System.out.println("休息！");
//    }
    public void study(){
        System.out.println("学习！");
        rest();
        System.out.println(this.name);
    }
    public Student(String name, int height, String major){
        this.name = name;
        this.height = height;
        this.major = major;
    }
}
class Boy extends Person{
}

注：instanceof是二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建的对象时，返回true

java中只有单继承

Java中类没有多继承，接口有多继承

子类继承父类，可以继承父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如，父类私有的属性和方法）

如果定义一个类时，没有调用extends，则它的父类是java.lang.Object

Object类

所有类都是Object类的子类，也都具有Object类的特性

如果类的声明中未使用extends类，则默认继承Object类

public class TestObject extends Object {
    String name;
    String pwd;
​
    @Override
    public String toString() {
        return "账户名："+name+"密码："+pwd;
    }
​
    public static void main(String[] args) {
        TestObject to = new TestObject();
        System.out.println(to.toString());
        TestObject to3 = new TestObject();
        System.out.println(to3.toString());
    }
}

方法重写override

override和overload无关！

子类重写父类的方法，可用自身行为替换父类行为。重写是实现多态的必要条件。

方法重写的三个要点：

方法名、形参列表相同

返回值类型和声明异常类型，子类小于等于父类

访问权限，子类大于等于父类

public class TestOverride {
    public static void main(String[] args) {
        Horse h = new Horse();
        h.run();
        h.getVehicle();
        Plane p = new Plane();
        p.run();
    }
}
class Vehicle{//交通工具类
    public void run(){
        System.out.println("跑……");
    }
    public Vehicle getVehicle(){
        System.out.println("给你一个交通工具");
        return null;
    }
}
class Horse extends Vehicle{
    @Override//覆盖
    public void run() {
        super.run();
        System.out.println("de de de");
    }
​
    @Override
    public Horse getVehicle() {
        return new Horse();
    }
}
class Plane extends Vehicle{
    @Override
    public void run() {
        System.out.println("fei fei fei");
    }
}
​
​

final关键字

修饰变量：一旦赋初值，就不能被重新赋值

修饰方法：该方法不可被子类重写。但是可以被重载

修饰类：修饰的类不能被继承

组合

将父类对象作为子类的属性

组合比较灵活，继承只能有一个父类，但组合可以有多个属性

is a 使用继承；has a使用组合

public class TestComponent {
​
}
class Person2 {
    String name;
    int height;
    public void rest(){
        System.out.println("休息！");
    }
}
class Student2 {
    Person2 person2 = new Person2();//组合
    String major;
    public void study(){
        System.out.println("学习！");
        person2.rest();
        System.out.println(this.person2.name);
    }
    public Student2(String name, int height, String major){
        this.person2.name = name;
        this.person2.height = height;
        this.major = major;
    }
}
class Boy2 extends Person2{
}

IDEA 快捷键

类的结构视图：alt+7

看类的源码：ctrl+左键

自动生成构造器get,set.equals等：alt+insert

查看错误：alt+enter

main ：public static void main(String[] args) {……}

sout：System.out.println();

soutm：System.out.println(“描述所在类中的所在方法”);

equals方法的重写

”==“代表双方是否相同

equals（）提供“对象内容相等”的逻辑

equals（）默认是比较两对象的hashcode。但是可以根据自己要求重写equals方法

super

可以看做是直接父类对象的引用，可通过super来访问父类中被子类覆盖的方法和属性

在一个类中，若是构造方法的第一行没有调用super（）或者this（），那么java就会默认调用super（）含义是调用父类的无参构造

静态初始化块调用顺序与构造方法调用顺序相同

public class TestSuper {
    public static void main(String[] args) {
        new ChildClass().f();
    }
}
class FatherClass{
    public int value;
    public void f(){
        value = 100;
        System.out.println("FatherClass.vale"+value);//soutm
    }
}
class ChildClass extends FatherClass{
    public int value;
    public int age;
    public void f(){
        super.f();//调用父类的普通方法
        value = 200;
        System.out.println("ChildClass.value"+value);
        System.out.println(value);
        System.out.println(super.value);//调用父类的成员变量
    }
    public void f2(){
        System.out.println(age);
    }
}

public class TestSuper02 {
    public static void main(String[] args) {
        new ChildClass2();
    }
}
class FatherClass2{
    static {
        System.out.println("jing tai father");
    }
    public FatherClass2(){
        System.out.println("创建fatherclass2");
    }
}
class ChildClass2 extends FatherClass2{
    static {
        System.out.println("静态初始块：ChildClass");
    }
    public ChildClass2(){
        //super();//编译器自动加入
        System.out.println("创建childclass2");
    }
}
​