关于java:JAVASE四面向对象下

访问控制修饰符

public

容许跨工程拜访的类

protected

容许同包类 + 子类拜访

default

（不写修饰符默认暗藏）同包类

private

只容许本类拜访

权限大小比拟

public > protected > default > private

this 和 super 关键字

this

this 代表本类对象的一个援用对象。

– 构造函数中，this()必须放在第一行。
– 当局部变量和成员变量同名时，用于辨别。
– 构造方法之间相互调用

public class Test_This {public static void main(String[] args) {new Demo().test();// 通过对象, 来拜访类里的成员(成员变量和成员办法)
    }
}    
class Demo{
    int count = 20 ;// 成员变量
    public void test() {
        int count = 10;// 局部变量
        System.out.println(count);//10, 变量的就近准则, 会应用局部变量 的值 
        // 想要应用  和  局部变量 同名的 成员变量 count--this 调用成员变量
        //this 示意的是本类的对象的援用 -- 底层帮你 new 了一个本类对象 --Demo this = new Demo();
        System.out.println(this.count);//20, 成员变量
    }
}

public class Test_This2 {public static void main(String[] args) {new Demo2(1);
        // 输入：// 无参结构
        // 含参结构 1

    }
}
class Demo2{public Demo2() {System.out.println("无参结构");
     }
     public Demo2(int a) {this();// 在构造方法中, 应用 this 关键字, 必须是第一条语句
         System.out.println("含参结构"+a);
     }
}

super

super 代表父类对象的一个援用对象

– 通过 super 关键字能够应用父类的内容
– 如果用 super，必须呈现在调用地位的第一行

public class Test_Super {public static void main(String[] args) {new Zi3();    // 父类无参结构
                  // 子类无参结构
    new Zi3("含参"); // 父类无参结构
                    // 子类含参结构
}
}

class Fu3{
// 如果父类有含参结构，子类找不到无参结构，须要在子类中应用 super 去调用父类的含参结构    
    public Fu3(String name) {System.out.println("父类含参结构");
    }
}
class Zi3 extends Fu3{public Zi3() {//super()；如果没有 super，在此处暗藏了 -- 子类的构造方法中都会暗藏着父类的无参结构
        super("含参");
        System.out.println("子类无参结构");
    }
    public Zi3(String name) {// 此处也暗藏了 super(); 证实子类每一个结构都暗藏了父类无参结构
        super("含参");
        System.out.println("子类含参结构");
    }

}

this 和 super 比拟

1、this 代表本类对象的援用，super 代表父类对象的援用。
2、this 用于辨别局部变量和成员变量
3、super 用于辨别本类变量和父类变量
4、— this. 成员变量 — this. 成员办法() — this(参数) 代表调用本类内容
5、–super. 成员变量 –super. 成员办法()–super(参数) 代表调用父类内容
6、this 和 super 不能够同时呈现在同一个构造方法里，他们两个只有呈现都得放在第一行，同时呈现的话，到底第一行放谁呢。。

static 和 final 关键字

static

static 用于润饰成员（变量 & 办法），使其成为动态资源。

特点

1、能够润饰成员变量，成员办法
2、随着类的加载而加载，优先于对象加载
3、只加载一次，就会始终存在，不再开拓新空间
4、全局惟一，全局共享
5、能够间接被类名调用
6、动态只能调用动态，非动态能够随便调用
7、static 不能和 this 或者 super 共用，因为有 static 时可能还没有对象

public class Test_Static {public static void main(String[] args) {
        //2, 动态资源优先于对象加载, 因为是随着类的加载就曾经加载了
        Student.coding();//null
                        // 正在敲代码
        System.out.println(Student.name);//null
        Student s = new Student();
        s.study();//10
                   //null
                   //null
                  // 正在敲代码
                  // 正在学习 java
        System.out.println(s.age);//10
        //1, 动态资源, 多了一种拜访形式, 除了能够用对象拜访, 更提倡用类名间接调用
        Student.coding();//null
                          // 正在敲代码
        System.out.println(Student.name);//null
        //3, 动态资源是共享资源, 可能被多个对象共享
        Student s1 = new Student();
        s1.name="张三";
        Student s2 = new Student();
        System.out.println(s2.name);// 张三
    }
}
class Student{
    // 一般资源 
    int age = 10;
    public void study() {
        //6, 非动态调用关系? -- 调用任意资源
        System.out.println(age);
        System.out.println(name);
        coding();
        System.out.println("正在学习 java");
    }
    // 动态资源
    static String name ;
    static public void coding()  {
        //4, 动态资源里, 不能应用 this 或者 super 关键字!
        //this.study();
        //super.
        //5, 动态调用关系? -- 只能调用动态, 不能调用非动态的
        System.out.println(name);
        System.out.println("正在敲代码");
    }
}

final

final 示意最终，能够润饰类、成员变量、成员办法。

特点

1、被 final 润饰的类，不能被继承
2、被 final 润饰的办法，不能被重写
3、被 final 润饰的变量是个常量，值不能被更改
4、常量的定义模式：final 数据类型 常量名 = 值

public class Test_Final {public static void main(String[] args) {Zi d = new Zi();
           d.speak();//Fu..speak()
           System.out.println(d.name);// 欢欢
           d.test();// 欢欢}
}
class Fu{
    //final class Fu{
    //1，被 final 润饰的类，不能被继承
    final String name="欢欢";
    public final void speak(){System.out.println("Fu..speak()");
    }
}
class Zi extends Fu{//public void speak(){ }
    //2，被 final 润饰的办法，不能被重写
    public void test(){
    //super.name="大黄";
    //3，被 final 的变量，不能从新被赋值
           System.out.println(super.name);
    }
}

异样

用来封装错误信息的对象（bug）。

组成构造：类型，提醒，行号。

Throwable

Throwable - 顶级父类
    -Error：零碎谬误，无奈修复
    -Exception：可修复的谬误
        -RunTimeException
            -ClassCastException
            -ClassNotFoundException

Exception

程序中遇到了异样（Exception），通常有两种解决形式：捕捉或者向上抛出。
当调用了一个抛出异样的办法时，调用地位能够不做解决持续向上抛出也能够捕捉异样。

1. 捕捉异样（应用 try{}catch{}）

try{须要捕捉的代码}catch(异样类型  异样名){解决计划}

测试

import java.util.InputMismatchException;
import java.util.Scanner;
// 测试 异样
public class Test_Exception {public static void main(String[] args){method();// 捕捉异样
    }
    /* 捕捉异样
     * try{代码...}catch(异样类型 异样名){正当的解决方案}
     * 异样类型: ArithmeticException  /  InputMismatchException
     */
    public static void method() {
        try {int a = new Scanner(System.in).nextInt();
            int b = new Scanner(System.in).nextInt();
            System.out.println(a/b);
        }catch(InputMismatchException a) {System.out.println("请输出两次整数!");
        }catch(ArithmeticException a) {System.out.println("第二次输出的整数不能为 0 !");
        }catch(Exception a) {
            // 怎么捕捉其余的所有异样呢?-- 多态 -- 通用性强 - 不关怀子类类型, 把子类当做父类来看
            // 所有 Exception 的子类都能被捕捉!
            System.out.println("请输出正确的数据!!");
        }
    }
}

多组数据后果

0
0.1
请输出两次整数!

5
0
第二次输出的整数不能为 0 !

2. 抛出异样（办法上应用 throws 异样类型）

main() throws InputMismatchException{}

测试

import java.util.Scanner;
public class Test_Exception2 {public static void main(String[] args){
        try {// 调用了抛出异样的 method2(), 须要解决, 捕捉或者抛出二选一
        method2();// 抛出异样}catch(Exception e) {System.out.println("运算谬误!");
        }
    }
    /* 抛出异样
     * 在办法申明上加 throws 异样类型 1, 异样类型 2...
     */
    public static void method2() throws Exception{int a = new Scanner(System.in).nextInt();
        int b = new Scanner(System.in).nextInt();
        System.out.println(a/b);
    }
}

5
0
运算谬误!

代码块

被 {} 包起来的一段代码就叫代码块

结构代码块

特点

1、在类的外部，办法内部，的代码块。
2、通常用于抽取构造方法中的共性代码。
3、每次调用构造方法前都会调用结构代码块
4、优先于构造方法加载

部分代码块

特点

1、在办法外面的代码块
2、通常用于控制变量的作用范畴，出了括号就生效
3、变量的范畴越小越好，成员变量会有线程平安问题

动态代码块

随着类的加载而加载，并且只被加载一次，个别用于我的项目的初始化

static{…}// 在成员地位, 领有 static 关键字的代码块

特点

1、动态代码块：static{}，地位：在类里办法外
2、在类加载时就执行，不论创立多少对象，只会执行一次的代码块

执行程序（代码块 + 构造方法 + 继承）

总体程序：
启动程序 -> 父类动态代码块 -> 子类动态代码块 -> 子类 main 办法 -> new SubClass() -> 父类结构代码块 -> 父类构造方法中部分代码块 -> 子类结构代码块 -> 子类构造方法中部分代码块

class Parent {
    public static String p_StaticField = "父类 - 动态变量";
    public String    p_Field = "父类 - 变量";
    protected int    i = 1;
    protected int    j = 2;
    static {System.out.println( p_StaticField);    // 1.
        System.out.println("父类 - 动态代码块");  //2.
    }
    {System.out.println( p_Field);  // 7.
        System.out.println("父类 - 结构代码块");  // 8.
    }
    public Parent()
    {System.out.println( "父类 - 部分代码块");    // 9.
        System.out.println("i=" + i + ", j=" + j);    // 10.
        j = 3;
    }
}
public class SubClass extends Parent {
    public static String s_StaticField = "子类 - 动态变量";
    public String s_Field = "子类 - 变量";
    static {System.out.println( s_StaticField);    // 3.
        System.out.println("子类 - 动态代码块");  // 4.
    }
    {System.out.println( s_Field);  // 11.
        System.out.println("子类 - 结构代码块");  // 12.
    }
    public SubClass()
    {System.out.println( "子类 - 部分代码块");    // 13.
        System.out.println("i=" + i + ",j=" + j); //14.
    }
    public static void main(String[] args )
    {System.out.println( "main 办法开始");   // 5.
        new SubClass(); // 6.}
}

执行后果：

父类 - 动态变量
父类 - 动态代码块
子类 - 动态变量
子类 - 动态代码块
main 办法开始
父类 - 变量
父类 - 结构代码块
父类 - 部分代码块
i=1, j=2
子类 - 变量
子类 - 结构代码块
子类 - 部分代码块
i=1,j=3

抽象类和接口

抽象类

概念

Java 中能够定义没有办法体的办法，该办法由其子类来具体的实现。该没有办法体的办法咱们称之为形象办法，含有形象办法的类咱们称之为抽象类。

特点

1、通过 java 关键字 abstract 实现
2、能够润饰办法或者类
3、抽象类中能够没有形象办法（由子类去实现）
4、如果类中有形象办法，那该类必须定义为一个抽象类
5、子类继承了抽象类当前，要么还是一个抽象类，要么就把所有形象办法都重写
6、多用于多态中
7、抽象类不能够被实例化

import java.io.IOException;
import java.io.Reader;
// 测试 抽象类
public class Test_Abstract {public static void main(String[] args) {
        // 创立多态对象 -- 父类援用 指向 子类对象
        //Animal2 a = new Dog2();//8, 抽象类不能被实例化
        Animal2 a = new Cat2();
        a.eat();// 父类的办法申明, 父类的办法体
        a.sleep();// 父类的办法申明, 子类的办法体(重写了)
    }
}
//1, 为什么产生父类?-- 为了提取子类的共性, 进步父类代码的复用性
//2, 怎么优化父类?-- 程序设计 -- 父类有没有能够省略的性能 -- 办法体能够省略
//4, 如果类里蕴含形象办法, 那么, 这个类就是一个抽象类
//5, 应用 abstract 关键字形容形象
abstract class Animal2{public void eat() {System.out.println("Animal...eat()");
    }
//3, 如果有办法体, 写了也要被批改, 那就能够省略不提供 -- 没有办法体的办法 -- 形象办法
    abstract public void sleep() ;}
//6, 子类继承抽象类后, 就继承来了形象办法, 是一个 形象的 子类
abstract class Dog2 extends Animal2 {
}
//7, 子类继承抽象类后, 子类能够重写 所有的 形象办法
class Cat2 extends Animal2 {
    @Override// 注解, 作用是用来标记这个办法是一个重写办法
    public void sleep() {System.out.println("猫吃鱼");
    }
}
class SubReader extends Reader{
    // 形象办法必须重写, 否则就是一个抽象类
    // 一般办法不是必须重写, 而是要改才重写
     public void close() throws IOException{System.out.println("close()");
     }
     public int read(char cbuf[], int off, int len) throws IOException{System.out.println("read()");
         return 0 ;
     }
}

构造方法

1、抽象类里有构造方法
2、抽象类本人不能被实例化, 依然会提供构造方法, 用于帮忙子类初始化
3、当创立子类对象时, 会触发子类的构造方法, 子类的构造方法里第一条默认就会有 super()
4、构造方法的执行程序: 父类的 –> 子类的

public class Test_Abstract2 {public static void main(String[] args) {
        //2, 先执行父类的 构造方法 , 再执行本人的构造方法
        Animal3 a = new Dog3();}
}
// 创立抽象类 
abstract class Animal3{
//3, 抽象类不能被实例化, 为什么还要提供构造方法?-- 为了不便子类 new
    public Animal3() {System.out.println("Animal3.. 无参结构");
    }
}
class Dog3 extends Animal3{public Dog3() {super();//1, 默认就存在, 会被动找父类的无参结构
        System.out.println("Dog3.. 无参结构");
    }
}

成员变量和成员办法

1、既能够有变量，也能够有常量。
2、抽象类里，既能够有一般办法，有能够有形象办法。
3、抽象类里能够都是一般办法, 目标是不让外界实例化

测试成员变量

public class Test_Abstract3 {public static void main(String[] args) {System.out.println( new Demo2().age );//10
        //new Demo2().name = "123" ;final 的常量, 值不能被批改
        System.out.println(new Demo2().name );//Demo
    }
}
abstract class Demo{
    int age = 10 ;
    final String name = "Demo";
}
class Demo2 extends Demo{}

测试成员办法

public class Test_Abstract4 {public static void main(String[] args) {Demo3 d = new Demo5();//Demo3 Demo4 都是抽象类不能 new
        d.save();// 多态的目标是统一标准, 所有向父类看齐
        d.delete(10);
        d.update("jack");
    }
}
//1, 抽象类是一个非凡的类, 非凡在 类里能够有一般办法和 形象办法，怎么决定类里的办法到底设计成一般办法还是形象办法呢?-- 看办法体有没有必要提供
abstract class Demo3{public void save() {System.out.println("数据保留胜利!");
    }
    abstract public void delete(int id) ;
    abstract public void update(String name) ;
}
//2, 子类继承了抽象类, 只重写了一部分形象办法, 也就是还蕴含着形象办法, 所以依然是一个抽象类
abstract class Demo4 extends Demo3{public void delete(int id) {System.out.println("delete().."+id);
     }
}
class Demo5 extends Demo4{public void update(String name) {System.out.println("update().."+name);
    }
}

接口

Java 外面因为不容许多重继承，所以如果要实现多个类的性能，须要能够通过实现多个接口来实现。

Java 接口和 Java 抽象类代表的就是形象类型，就是咱们须要提出的形象层的具体表现。OOP[面向对象]的编程，如果要进步程序的复用率，减少程序的可维护性，可扩展性，就必须是面向接口的编程，面向形象的编程，正确地应用接口、抽象类这些太有用的形象类型做为 java 构造档次上的顶层。

特点

1、接口中都是形象办法
2、通过 interface 关键字创立接口
3、通过 implements 让子类来实现
4、能够了解成，接口是一个非凡的抽象类
5、接口冲破了 java 的单继承的局限性
6、接口和类之间能够多实现，接口和接口之间能够多继承
7、接口是对外裸露的规定，是一套开发标准
8、接口进步了程序的性能扩大，升高了耦合性

public class Test_Interface {public static void main(String[] args) {
        //6, 接口和抽象类一样, 都不能够被实例化
        Demo d = new DemoImpl();
        //7, 多态对象为了对立调用规范, 以父类为准
        d.save();
        d.delete();}
}
//1, 通过 interface 关键字, 定义接口
interface Demo{//2, 接口里全都是形象办法(jdk1.8 后能够是 default/static 的一般办法)
    abstract public void save() ;
    abstract public void delete() ;}
//3, 实现类想要应用接口的性能, 须要和接口产生实现关系(相似继承)
//5, 实现类实现了接口, 能够重写 所有 形象办法
class DemoImpl  implements  Demo{
    @Override// 注解
    public void save() {System.out.println("数据保留胜利!");
    }
    @Override// 注解
    public void delete() {System.out.println("数据删除胜利!");
    }
}
//4, 实现类实现了接口, 能够是一个形象的实现类
//abstract class DemoImpl  implements  Demo{}

接口的应用

构造方法

接口里是没有构造方法的。在创立实现类的对象时默认的 super()，是调用的默认 Object 的无参结构。

成员变量

接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上 public static final

成员办法

接口里的办法 – 都是形象办法 (java1.8 前);
能够有 static 或者 default 的一般办法(java1.8 后)

public class Test_Interface2 {public static void main(String[] args) {
        //3, 应用接口里的动态常量?
        //Inter.age = 30 ;// 是 final 的常量
        System.out.println(Inter.age);//20，是 static 的资源
        System.out.println(new InterImpl().age );//20
        Inter in = new InterImpl();
        in.show();// 这是 jdk1.8 的新个性
        in.save();// 数据保留胜利!
        Inter.test();// 这是 jdk1.8 的新个性 -- 通过类名间接拜访接口里的一般的静态方法} 
}
interface Inter{
    //1, 接口里有没有构造方法?-- 没有 -- 实现类到底怎么 new 的?--
    //2, 接口里有没有变量?-- 没有!! 是 static 的 final 的常量 public 的
    //public static final int age = 20 ;// 接口会为你的变量, 主动拼接 public static final 
    int age = 20 ;// 简写模式
    //4, 接口里有没有一般办法?-- 有, 只不过是 jdk1.8 才提供的, 必须润饰成 default/static
    default public void show() {System.out.println("这是 jdk1.8 的新个性");
    }
    static public void test() {System.out.println("这是 jdk1.8 的新个性");
    }
    //5, 接口里有没有形象办法?-- 有
    //abstract public void save() ;// 接口会为你的形象办法, 主动拼接 public abstract
    void save() ;// 简写模式}
//6, 实现类实现接口后, 对于一般办法必须重写吗?-- 不是, 要改才重写
//7, 实现类实现接口后, 对于形象办法必须重写吗?-- 是, 否则就是一个形象的实现类
class InterImpl extends Object implements Inter{public InterImpl() {
        // 不是接口里的构造方法, 因为接口基本没有构造方法, 其实找的是 Object 的构造方法
        super();}
    @Override
    public void save() {System.out.println("数据保留胜利!");
    }
}

接口简单用法

1、接口之间能够多继承，多个接口之间逗号隔开（突破了 java 单继承的局限性，）
2、接口还能够多实现，只不过接口之间逗号隔开
3、接口甚至还能够单继承的同时多实现

import java.io.Reader;
public class Test_Interface3 {public static void main(String[] args) {
        //2, 左侧写的接口到底是谁?-- 要看你想用哪个接口的性能, 左侧就写谁
        Inter2 in = new Inter2Impl() ;
        in.save();// 数据保留胜利!
        int rows = in.update(2) ;// 数据曾经更新
        System.out.println(rows);//5
        System.out.println(in.update(2) );// 数据曾经更新
                                           //5
        in.delete("jack");// 删除记录胜利!jack
    }
}
interface Inter1{void save();
    int update(int id);
}
interface Inter3{void delete(String name);
}
//1, 接口间是继承关系, 而且能够多继承
interface Inter2 extends Inter1 , Inter3{ }
//4, 实现类和接口, 是实现关系, 还能够多实现
class Inter3Impl implements Inter3 , Inter1 {public void delete(String name) {System.out.println("删除胜利!");
    }
    public void save() {System.out.println("保留胜利!");
    }
    public int update(int id) {System.out.println("更新胜利!");
        return 5;
    }
}
//5, 实现类能够在单根继承的同时, 多实现
//Inter4Impl 须要重写 Inter1 和 Inter3 里的 所有形象办法, 否则就是一个抽象类
abstract class Inter4Impl extends Object implements Inter1 , Inter3{ }
//3, 实现类, 实现了接口. 须要把接口里 所有形象办法都重写.
//Inter2 接口里的 3 个办法都要重写
class Inter2Impl implements Inter2{
    @Override
    public void delete(String name) {System.out.println("删除记录胜利!"+name);
    }
    @Override
    public void save() {System.out.println("数据保留胜利!");
    }
    @Override
    public int update(int id) {System.out.println("数据曾经更新");
        return 5;
    }
}

抽象类和接口的区别

相同点

1、都能够呈现形象办法
2、都不能被实例化
3、都须要子类重写形象办法
4、接口和抽象类体现了继承构造里的形象层

不同点

1、抽象类里有构造方法, 用来给子类创建对象. 接口里没有构造方法.
2、抽象类里有变量, 然而接口里, 只有常量, 会为简写的常量主动拼接 public static final
3、抽象类里有一般办法, 然而接口里, 都是形象办法(除了 jdk1.8)
4、接口里的形象能够简写, 会为简写的形象办法主动拼接 public abstract
5、抽象类只能是和子类之间产生单根继承关系
6、接口和实现类之间是实现关系, 而且能够多实现
7、接口和接口之间是继承关系, 而且能够多继承
8、接口是为了冲破 java 单继承的局限性来的