java基础笔记-面向对象2

8. static

8.1 概述

? 希望属性or方法不归具体的对象所有，而是属于类，

? 随着类的加载而加载

在内存池中，就存一份，在方法区的静态域中

8.2 静态属性

? static可以用来修饰：属性，方法，代码块，内部类

class chinese{
    private static String contory; //全内存就一份，所有对象共享
    private String name;
}

8.3 静态方法

? 调用关系，看生命周期

? 静态方法中，不能使用this，super

8.4 单例模式

? 单例：单独的一个实例，某个类只能创建一个对象

? 构造方法权限为private，这样不能在外部使用new来创建

? 在内部使用一个静态方法来创建一个对象,同时，由于静态方法只能访问静态成员变量，所以类的所有成员都得是静态的

8.4.1创建单例模式的两种方法

? 饿汉式线程安全，但是对象加载时间过长

? 懒汉式延迟对象的创建线程不安全（两个线程同时想创建单例对象，俩人判断都是null，就各自会new一个）

//饿汉式
class Singleton1{
    //私有构造方法
	private Singleton1(){
        pass;
    }
    //类内部创建对象
    private static Bank ins = new Singleton1();
    //提供共有方法返回类的对象
    public static Singleton1 getInstance(){
        return ins;
    }
}

//懒汉式
class A{
	private A(){
		pass;
	}
    //声明当前类对象，不初始化
    private static A ins = null;
    //提供共有方法返回类的对象
    public static A getInsance（）{
        if(ins==null){
            ins = new A();
        }
    	return ins;         
    }
}

8.4.2 使用场景

? 数据库连接池，网站计数器，日志处理，配置文件类，windows任务管理器，回收站，Application

9. 代码块 ( 初始化块 )

? { 代码块 } static{代码块}

? 通常都是用来初始化类或者对象的，

? 只能用static修饰，或者不修饰

? 代码块可以有多个，按着先后顺序先后执行(没必要写俩静态代码块吧。)（甚至，没必要写代码块）

9.1静态代码块

? 随着类的加载而执行！

? 就执行一次

9.2 非静态代码块

? 随着对象的创建而执行

? 每创建一个对象都执行一次

? 作用：可以在对象创建时，对属性进行初始化

10. final

? final可以用来修饰：类（简单的说，割了），方法（不可以被重写，你爸爸给你用，但是不给你重写），变量

10.1 final修饰方法和类

? 权限 [final] class A{ }

? [权限] [final] [static] [final] 返回值方法名()

? 被final修饰的类：String，System，StringBuffer

? 被final修饰的方法：Object的getClass()

10.2 final修饰变量和属性

? 变量：变成常量了

? 属性：赋值可以放在：显式初始化位置，代码块中，构造器中。不能用在对象.属性处

? 局部变量: 方法内：变成常量

? 形参：方法体内就不能再修改了

10.3 static+final

? static final 修饰属性：全局常量常见于接口中

11. 抽象类，抽象方法

? 儿子太多，导致父类变成了一个公共东西的抽象，那么实际使用对父类对象的使用就少了，那还要父类干嘛，写成抽象类，不做实例化了

? abstract ：用来修饰类，方法

abstract class  Person{
    String name;
    int age;
    public Person（）{
        
    }
}
class Sun{
    
}

11.1抽象类

? 一定要有构造方法，虽然自己不能用，但是可以给实现的子类来用

11.2 抽象方法

? 该类必须是抽象类

? 可以没有抽象方法，可以有普通成员方法，这个成员方法还可以调用抽象方法

? 不能修饰构造方法，私有方法，静态方法，final方法

11.3抽象类的匿名子类

? 真的很常见

? 抽象类的方法太多了就别用了！

abstract class Person{
    public abstract void eat();
}

//方法声明
public static void function(Person p){}
//调用
function(new Person{
    @override
    public void eat(){}
})

11,4 设计模式：模板方法

? 功能内部的一部分是现实确定的，一部分是现实不确定的，这时可以把不确定的部分暴露出去，留给子类来实现

12. interface

? 接口的最主要目的就是实现多继承，次要目的就是单纯的抽象多个类的公共特征

? implements 实现

? 实现类如果没有implements接口中的所有方法，则该类是一个抽象类

12.1 接口的成员：

? JDK7:

? 全局常量： public static final

? 抽象方法：public abstract

? JDK8+：

? 还可以定义：

? 静态方法: 可以有方法体（接口越来越像类靠齐了）

? 但是有个接口A{ static func1()}，实现类B b，调用时 b.func1()

? 只能A.func1();

? 默认方法：默认方法使用default修饰，可以通多实现类对象调用，可以重写，但是要去掉default

? 绝对不能定义构造方法

interface Flyable{
    //全局常量
    public static final int MAX_SPEED =7900;
    int MIN_SPEED =7900; //同上，省略了(包括省略了public)
 	//抽象方法
    public abstract void fly();
    void stop();//省略同上
    //静态方法
    public static void method1(){
        
    }
    //默认方法
    public default void method2(){} //default默认 得写
    default void method3(){} //省略
}

12.2接口的继承性

? java可以多实现接口，接口之间可以多继承！！！

12.3 (多继承)带来的重名问题

? 父类和接口中有重名函数 ,规定，子类不重写则默认用父类的 --类优先原则

? class A extends B implements C{ }

? 俩接口里面有重名函数，规定：

? <1>如果定义的是默认方法，则实现类必须重写(接口冲突)，如果想使用接口的默认方法，则B.super.func()

class A  implements B，C{  }

12.3 接口的使用(多态)

interface USB{
	void start();
    void stop();
}
class Flash implements USB{
    public void start(){}
    public void stop(){}
}
class Computer{
    public void transferData(USB sub){
        usb.start();
        ...
        usb.stop(); 
    }
}
main(){
    Computer com =new Computer();
    //非匿名实现类的对象
    Flash flash =new Flash();
    com.transferData(flash)
        
  
    //匿名实现类的匿名对象
    comg.transferData(new USB{
        public void start(){}
   	 	public void stop(){}
    });
}

12.4设计模式：代理模式

? 使用较多

? 就是为其他对象提供一种代理以控制对这个对象的访问

? 一个接口，被俩类实现，一个代理类，一个被代理类

interface NetWork{
	public void browse();
}
//被代理类
class Server implements NetWork{
    @oiverride
    public void browse(){}
}
//代理类
class ProxyServer implements NetWork{
    private NetWork work;
    public ProxyServer(NetWork work){
        this.work = work;
    }
    public void check(){
        sout("联网前的检测");
    }
    @override
    public void browse(){
        check();
        work.browse();
    }
}

main(){
    Server server = new Server();
    ProxyServer proxyServer = new ProxyServer(server);
    proxyServer.browse();
}

? 应用场景：安全代理，屏蔽对真实角色的直接访问

? 远程代理：通过代理类处理远程方法调用（RMI）

? 延迟加载：先加载轻量级的代理对象，真正需要再加载真是对象

12.5设计模式：工厂模式

13. 内部类

? 内部类 TM只出现在面试中吧。。。。

? 自己做开发没事闲的扯什么犊子写这玩意。。。

? 活着不好么？？？

? 分类：成员内部类(static成员内部类，和非static成员内部类)

? 局部内部类(方法内，代码块内，构造方法内)，匿名内部类

class Person{
    public void method(){
        class A{}//方法体内局部innerclass
    }
    {
        class B{}//代码块内局部innerclass
    }
    public Person(){
        class C{}//构造方法内局部innerclass
    }
    class Heat{//成员内部类
        
    }
}

13.1成员内部类

? 作为类的成员：

? >能调用外部类的东西，但是要注意静态的关系

? >innerclass里面的this指的是内部类，想要调用外部类的属性，A.this.func()

? >可以被四种权限修饰

? 作为一个类：

? >类内可以定义的东西：当初普通类就行

? >可以被继承，可以被final修饰，可以抽象

class A{
	class B{
        int age;
        public void show(){}
    }	
    static class C{
        int age
    }
}

13.2内部类的实例化及区分

class Person{
	String name;
	public void eat(){sout("人吃饭")}
    static class Dog{
        String name;
        public void eat(){sout("狗吃饭")}
    }
    class Bird{
        String name;
        public void eat(){sout("鸟吃食")}
        //区分同名属性
        public void display( String name){
            sout(name);
            sout(this.name);
            sout(Person.this.name);
        }
    }
}
main(){
    Person.Dog dog = new Person.Dog(); //创建静态成员内部类
    dog.eat();
    
    Person p = new Person();
    Person.Bird bird = p.new Bird();//创建 非静态成员内部类
    bird.eat();
}

13.3 局部内部类

注意：方法体内的内部类，使用了方法体里面的局部变量，这个变量必须是final，哪怕你不声明，它也会默认final，你敢改变量值，他就敢报错

JDK6之前，不写final也报错

why:局部变量的声明周期，除了函数，就没了，而类呢，哪怕是局部类，他也是直到不用了才销毁的，问题来了，类还在，变量没了，咋办？只能final

class Person{
    
    //开发中巨少见
    public void method(){
        class A{}//方法体内局部innerclass
    }
    
    //真实情况，返回一个实现了Comparable接口的类的对象
    //方法1
    public Comparable getComparable(){
        class MyComparable implements Comparable{
            ...
        }
        return new MyComparable();
    }
    //方法2，不标准
    public Comparable getComparable(){
        return new Comparable(){
            @override
            ...
        };
    }
    
    {
        class B{}//代码块内局部innerclass
    }
    public Person(){
        class C{}//构造方法内局部innerclass
    }
}

java基础笔记 java 笔记基础