Java整理

Final关键字

final 可以修饰的结构:类、方法、变量
      用来修饰一个类，此类不能被其他类所继承
    用来修饰方法：表明此方法不能被重写
    用来修饰变量，此时的'变量'就称为一个常量
     修饰属性、可以考虑赋值的位置：显示初始化、代码块初始化、构造器初始化
    修饰局部变量 尤其是使用final修饰形参时，表明此形参是一个变量，当我们调用此方法，给常量形参赋值一个实参，一旦赋值以后，就只能在方法体内使用形参，但不能进行重新赋值
    static final 表示用来修饰属性  全局变量
 final所有的方法都不能被重写(但是可以被重载),所以不能同时使用abstract和final修饰类的方法，但是子类可以使用父类中final修饰的

static关键字的使用

static 关键字的使用
    静态的
    可以用来修饰属性、方法、代码块、内部类//随着类的加载而加载
    使用static修饰属性： 静态变量
        按照是否使用static修饰，又分为：静态属性 VS 非静态属性(实例变量)
         实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，但修改其中一个对象的非静态属性时，不会导致其他对象中同样的属性值的修改。
          静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，时发生修改了的。
    static 修饰属性的其他说明：
             ①静态变量随着类的加载而加载，可以用过"类.静态变量"的方式调用
             ②静态变量的加载要早于对象的创建
             ③由于类只会加载一次，则静态变量中在内存中也只会存在一份，存在方法区的静态域中
    使用static修饰方法：静态方法
             ①随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
             ②静态方法中只能调用静态的方法或属性
             ③非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
      static注意点：
             在静态方法中，不能使用this super关键字(this指明了本类中构造器的初始化，super代表了父类中的构造器中的初始化)(静态方法中static是随着类的加载而加载的，而super和this是随着对象创建而加载)(慢的可以加载快的，而快的不能加载慢的)
             

this关键字

this可以用来修饰:属性、方法、构造器、调用
this修饰属性和方法
    this理解为：当前对象
    在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this.变量"的方式，表明此变量是属性 ，而非形参。
this调用构造器
    我们在类的构造器中，可以显示的使用"this(形参列表)"方式，调用本类中指定的其他构造器
    构造器中不能通过"this(形参列表)"方式调用自己
    'this.(形参列表)'必须声明在当前构造器的首行
    构造器内部，最多只能声明一个"this(形参列表)"用来调用其他构造器(因为this和super只能在方法体内声明一个，而且必须是首行)
注意事项：
    只能在构造方法中使用this()调用其他的构造方法，不能在成员方法中使用
    不能再一个类中的两个构造方法中使用this()互相调用

super关键字

super可以用来调用:属性、方法、构造器;
super的使用：
    我们可以再子类的方法或构造器中，通过使用"super.属性"或"super.方法"的方式，显示的调用
    特殊情况：当子类和父类中定义了同名的束形式，我们要再子类中调用父类欧洲那个声明的属性，则必须显示的使用"super.属性"的方式，表明调用是父类中声明的属性;

super调用构造器：
    我们可以再子类的构造器中显示的使用"super(参数列表)"的方式，调用父类中声明的指定的构造器
    "super(形参列表)"的使用，必须声明再子类构造器的首行
    我们再类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一,不能他同时出现。
   在构造器的首行，没有显示的声明"this(形参列表)"或"super(形参列表)"， 则默认调用的是父类空参的
    在类的多个构造器 中，至少有一个类的构造器中使用了"super(形参列表)".调用父类中的构造器   

包装类的转化

// 基本数据类型 --》包装类、调用包装类的构造器
Integer in1=new Integer("123");
Integer in2=new Integer("123aa");//报异常,编译能通过，运行报错
System.out.println(in1.toString());

Boolean b1=new Boolean(true);//true
Boolean b1=new Boolean(1);//true
Boolean b1=new Boolean(false);//false
除以一以外的任何数字
Boolean b1=new Boolean(x);//false

//包装类转化基本数据类型 包装类--》基本数据类型 调用包装类Xxx的xxx.Value()方法
Integer in1=new Integer(11);
int i1=in1.Value();
Float fl1=new Float(12.3);
float f1=fl1.floatValue();

// 基本数据类型，不能放入引用类性中 基本数据类型想让放入引用类型，必须转化为包装类
int num1=10;
Integer interger =new Integer(num1);


//想要数据进行加减乘除，就必须转化成基本数据类型
mother(integer);
/*
JDK5.0新特性：自动装箱、自动拆箱
**/
//自动装箱 包装类--》基本数据类型
int num2=10;
Integer integer=num2;//自动装箱
boolean b1=true;
Boolean b2=b1;
//自动拆箱 包装箱--》基本数据类型
Integer integer = 20;
int i1=integer;
System.out.print((int)integer);


//基本数据类型  包装类--》String类型 调用String重载的Valueof(Xxx xxx)
int num=10;
//方式一：
String str1=num+"";
//方式二：调用String的Valueof()
float f1=12.3f;
String str2=String.Vauleof(f1);
Double d1=new Double(12.5);
String str3=String.valueof(d1);

//String类型--》基本数据类型、包装类 调用parseXxx(String s)
String str1="123";
int num1=Integer.parseInt(str1);//123
String str2="true";
boolean b1=Boolen.parseBoolean(str2);//true

多态性

理解多态性：
    理解多态性：可以理解为一个事务的多种形态。
    何为多态性：对象的多态性，父类的引用指向子类的对象(或子类的对象赋给父类的引用)
    多态的使用，虚拟方法调用
    有了对象的多态性以后，我们再百年一起，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法
    总结：编译，看左边，运行，看右边;
多态性使用的前提①要有类的继承关系②要有方法的重写;
对象的多态性：只适用于方法，不适用于属性(编译和运行都看左边);
若子类重写了父类方法，就意味着类里定义的方法彻底覆盖了父类里的同名方法;
  系统将不可能把父类里的方法转移到子类中，运行看有右边;
对于实例变量则不存在这样的现象，即使子类里定义与父类完全相同的实例变量;
    这个实例变量依然不可能覆盖父类中顶一的实例变量，编译运行都看左边;

  //有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是由于变量声明为父类型，导致编译时，只能调用父类中声明的属性和方法。子类持有的属性和方法不能调用.如何才能调用子类持有的书信和方法？
        //向下转型 也叫强制类型转化
        Man m1=(Man)p2;// 强制将person类转化成man类
        m1.isSmoking=true;
        //使用强制时，可能出现ClassCastException的异常
//        Woman w1=(Woman)p2;
//        w1.goShopping();

/*
* instanceof关键字的使用

* a instanceof A ：判断对象a 是否是类A的实例。如果是，返回true， 如果不是，返回false
* 使用情景，为了避免在向下转型是出现CLassCastException的异常，我们在向下转型之前，先进行instanceof的
* 判断，一旦返回true，就进行向下转型，如果返回false，不进行向下转型。
* 如果a instanceof A 返回true，则a instanceof B也返回true
* 其中，类B是类A的父类
* */
//        if (p2 instanceof Woman) {
//            Woman w1=(Woman) p2;
//            w1.goShopping();
//            System.out.println("成功运行该");
//        }

面向对象

接口

/*
* 接口的使用：
* 1.接口使用interface来定义
* 2.Java中，接口和类是并列的两个结构
* 3.如何定义接口，定义接口中的成员
*   3.1JDK及以前，只能定义全局变量和抽象方法
*      抽象方法 public abstract
*      全局变量：public static final的 但是可以省略不写
*   3.2JDK8：除了定义全局变量和抽象方法之外，还可以定义静态方法、默认方法
*
* 4.接口不能定义构造器！意味着接口不可以实例化
* 5.Java开发中，接口通过让类去实现(implements)的方式来使用。
*   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
* 6.接口中的所有方法应该被重写
* 7.Java类可以实现多个接口 --》弥补了Java单继承性的局限性
* 格式：
*  class AA extends BB implements CC,DD{}
*8. 接口与接口之间可以继承，而且可以多继承
* 9.接口的具体使用，体现多态性
* 10.接口，实际上可以看做是一种规范
* */

package 接口;
/*
* 接口的使用
* 1.接口的使用上也满足的多态性
* 2.接口，实际上就是定义一种规范
* 3.开发中 体会面向接口编程
* */
public class USBTest {
    public static void main(String[] args) {
        Computer com=new Computer();
        //接口的多态性  创建了接口阿德非匿名实现类的非匿名对象
        Flash flash=new Flash();//实现类的对象，
        com.transferData(flash);
        //2创建了接口的非匿名是实现类的匿名对象
        com.transferData(new Printer());
        //创建类接口阿德匿名实现类的非匿名对象
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }
        };
        //创建了接口的匿名实现类的匿名对象
        com.transferData(new USB(){

            @Override
            public void start() {
                System.out.println("巩固走");
            }

            @Override
            public void stop() {
                System.out.println("结束");
            }
        });

    }
}
class Computer{
    public void transferData(USB usb){//接口不能被调对象 USB usb=new Flash();
        usb.start();
        System.out.println("具体输出数据的细节");
        usb.stop();
    }
}
interface USB{
    void start();
    void stop();

}
class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}
class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

代理模式

package 接口;
/*
*
* 1接口的应用  代理模式
*/
public class NetWorkTest {
    public static void main(String[] args) {
        Server server=new Server();
        ProxyServer proxyServer=new ProxyServer(server);
        proxyServer.browse();
    }
}
interface NetWork{
    void browse();
}
//被代理类
class Server implements NetWork{
    @Override
    public void browse() {
        System.out.println("真实的网络");
    }
}
//代理类
class ProxyServer implements NetWork{
    private NetWork work;

    public  ProxyServer(NetWork work){
        this.work=work;
    }
    public void check(){
        System.out.println("联网之前的检查工作");
    }

    @Override
    public void browse() {
        check();
        work.browse();
    }
}

匿名类

package 内部类;
/*
类的内部成员之五：内部类
1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类
2. 内部类的分类： 成员内部类（静态、非静态） VS 局部内部类(方法内、代码块内、构造器内)
 3. 成员内部类：一方面：作为外部类的成员
                     调用外部类的结构
                     可以被static修饰
                     可以被四种不同的权限修饰
               另一方面：作为一个类
                        类内可以定义属性、方法、构造器等
                        可以被final修饰，表示此类不能被继承，不使用可以被继承
                        可以被abstract修饰
4. 关注如下3个问题
   4.1 如何实例化成员内部类的对象
   4.2 如何在成员内部类区分外部类的结构
   4.3 开发中局部内部类的使用
 */
public class InnerClassTest {
    public static void main(String[] args) {
        //创建dog实例(静态的成员内部类)
        Person.Dog dog =new Person.Dog();
        dog.show();
        //创建Bird实例(非静态的成员内部类)
        Person person=new Person();//先对类进行实例化
        Person.Bird b =person.new Bird();
        b.sing();
    }
}
class Person{
    String name;
    int age;
    public void eat(){
        System.out.println("人，吃饭");
    }
    //非静态内部类
   static class Dog{
        String name;
        int age;
        public void show(){
            System.out.println("往往");
//           eat();//静态
        }
    }
    //静态内部类
     class Bird{
        String name;
        public Bird(){
        }
        public void sing(){
            System.out.println(Person.this.name);//调用Person当中name的属性
            System.out.println("我是一只鸟");
         Person.this.eat();//调用外部类的属性可以省略person.this.
        }
    }
    //局部内部类
    {class AA{}}
    public void method(){
        class BB{}
    }
    public Person(){
        class CC{}
    }
    //返回一个实现了COmparable接口的类的对象
    public Comparable getComparable(){
        //创建一个实现Comparable接口的类：局部内部类
//        class MyComparable implements Comparable {
//            @Override
//            public int compareTo(Object o) {
//                return 0;
//            }
//        }return new MyComparable();
        //    方式二
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}