Java语法基础学习DaySeven

---恢复内容开始---

一、包装类——Wrapper

1.定义：针对八种基本数据类型定义相应的引用类型——包装类（封装类）

boolean——Boolean          byte——Byte

short——Short                   int——Integer

long——Long                    char——Character

float——Float                     double——Double

2.作用：有了类的特点，就可以调用类中的方法

3.注意事项

(1)基本数据类型和包装类的转换：JDK5.0以后，自动装箱和拆箱，即基本数据类型和包装类可以无缝连接，自动转换。

(2)基本数据类型、包装类 - -> String类：调用String类的静态的重载的valueOf(Xxx  xx)方法，例：

int i = 10;
// Integer ii = 10;
String str = String.valueOf(i);//"10"
// String str1 = String.valueOf(ii);

(3)String类 - ->基本数据类型、包装类：调用包装类的parseXxx(String str)方法，例：

String str = "10";
int i = Integer.parseInt(str);

二、设计模式之单例模式

1.概述：使一个类只能创建一个对象

2.特点

(1)私有化构造器，使得在类的外部不能调用构造器创建对象

(2)在类的内部创建一个静态的私有的类的实例，因为静态的方法只能调用静态的变量和方法

(3)通过一个静态的类的方法来返回实例

3.代码

public class Test{

    public static void main(String[] args){
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);//输出true，说明是同一个实例
    }
}
//饿汉式
class Singleton{

    //私有化构造器
    private Singleton(){
    }
    //在类的内部创建实例
    private static Singleton instance = new Singleton();

    //通过公共的静态的方法来返回实例
    public static Singleton getInstance(){
        return instance;
    }
}
//懒汉式：延迟加载方式,可能存在线程安全问题
class Singleton1{

    private Singleton1(){}

    private static Singleton1 instance = null;

    public static Singleton1 getInstance(){
        if(instance == null){
            instance = new Singleton1();
        }
        return instance;
    }
}

三、抽象类——abstract

1.abstract修饰类，即抽象类的特点

(1)抽象类不可被实例化

(2)抽象类有构造器（凡是类都有构造器）

(3)抽象方法所在的类一定是抽象类

(4)抽象类中可以没有抽象方法

(5)只有通过子类继承抽象类并重写了所有的抽象方法后，该子类才可以实例化，否则，该子类还是一个抽象类，必须声明为抽象类。

2.abstract修饰方法，即抽象方法的特点

(1)格式：没有方法体，没有{}，如：public abstract void eat();

(2)抽象方法只保留方法的功能，而具体的执行交给继承抽象类的子类，由子类来重写此方法。

(3)abstract关键字不能修饰属性、私有方法、构造器、静态方法、final的方法。

3.模版方法设计模式——TemplateMethod

(1)概述：抽象类体现的就是一种模版模式的设计，抽象类作为多个子类的通用模版，子类在抽象类的基础上进行改造拓展。

(2)作用：当功能内部的一部分实现是确定的，一部分实现时不确定的，这时可以把不确定的部分暴露出去，让子类去实现。

(3)代码：

abstract class GetTime{
    public final void getTime(){//此功能不需要重写，加final修饰
        long start = System.currentTimeMillis();
        code();//不确定的功能部分，提取出来，通过抽象方法实现
        long end = System.currentTimeMillis();
        System.out.println("花费的时间是："+(end-start));
    }

    public abstract void code();//不确定的功能由子类来重写实现

}

class SubDemo extends GetTime{//子类实现code()抽象方法
    public void code(){
        for(int y = 0;y < 1000;y++){
            System.out.println("y");
        }
    }
}

四、接口——interface

1.概述：接口可以看成一个特殊的抽象类，是常量和抽象方法的一个集合，不能包含变量、一般的方法。

2.特点

(1)接口没有构造器

(2)常量和抽象方法的修饰符都是固定的：

　　常量：public static final

　　方法：public abstract

(3)接口定义的是一种未实现的功能，由类来实现(implements)，如：class CC extends DD implements AA

(4)实现接口的类，必须重写接口所有的抽象方法，才可以实例化，否则这个类仍为抽象类

(5)一个类可以实现多个接口

(6)接口与接口之间也可以是继承的关系，而且可以多继承，而类之间的继承只能是单继承的。

---恢复内容结束---

一、包装类——Wrapper

1.定义：针对八种基本数据类型定义相应的引用类型——包装类（封装类）

boolean——Boolean          byte——Byte

short——Short                   int——Integer

long——Long                    char——Character

float——Float                     double——Double

2.作用：有了类的特点，就可以调用类中的方法

3.注意事项

(1)基本数据类型和包装类的转换：JDK5.0以后，自动装箱和拆箱，即基本数据类型和包装类可以无缝连接，自动转换。

(2)基本数据类型、包装类 - -> String类：调用String类的静态的重载的valueOf(Xxx  xx)方法，例：

int i = 10;
// Integer ii = 10;
String str = String.valueOf(i);//"10"
// String str1 = String.valueOf(ii);

(3)String类 - ->基本数据类型、包装类：调用包装类的parseXxx(String str)方法，例：

String str = "10";
int i = Integer.parseInt(str);

二、设计模式之单例模式

1.概述：使一个类只能创建一个对象

2.特点

(1)私有化构造器，使得在类的外部不能调用构造器创建对象

(2)在类的内部创建一个静态的私有的类的实例，因为静态的方法只能调用静态的变量和方法

(3)通过一个静态的类的方法来返回实例

3.代码

public class Test{

    public static void main(String[] args){
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);//输出true，说明是同一个实例
    }
}
//饿汉式
class Singleton{

    //私有化构造器
    private Singleton(){
    }
    //在类的内部创建实例
    private static Singleton instance = new Singleton();

    //通过公共的静态的方法来返回实例
    public static Singleton getInstance(){
        return instance;
    }
}
//懒汉式：延迟加载方式,可能存在线程安全问题
class Singleton1{

    private Singleton1(){}

    private static Singleton1 instance = null;

    public static Singleton1 getInstance(){
        if(instance == null){
            instance = new Singleton1();
        }
        return instance;
    }
}

三、抽象类——abstract

1.abstract修饰类，即抽象类的特点

(1)抽象类不可被实例化

(2)抽象类有构造器（凡是类都有构造器）

(3)抽象方法所在的类一定是抽象类

(4)抽象类中可以没有抽象方法

(5)只有通过子类继承抽象类并重写了所有的抽象方法后，该子类才可以实例化，否则，该子类还是一个抽象类，必须声明为抽象类。

2.abstract修饰方法，即抽象方法的特点

(1)格式：没有方法体，没有{}，如：public abstract void eat();

(2)抽象方法只保留方法的功能，而具体的执行交给继承抽象类的子类，由子类来重写此方法。

(3)abstract关键字不能修饰属性、私有方法、构造器、静态方法、final的方法。

3.模版方法设计模式——TemplateMethod

(1)概述：抽象类体现的就是一种模版模式的设计，抽象类作为多个子类的通用模版，子类在抽象类的基础上进行改造拓展。

(2)作用：当功能内部的一部分实现是确定的，一部分实现时不确定的，这时可以把不确定的部分暴露出去，让子类去实现。

(3)代码：

abstract class GetTime{
    public final void getTime(){//此功能不需要重写，加final修饰
        long start = System.currentTimeMillis();
        code();//不确定的功能部分，提取出来，通过抽象方法实现
        long end = System.currentTimeMillis();
        System.out.println("花费的时间是："+(end-start));
    }

    public abstract void code();//不确定的功能由子类来重写实现

}

class SubDemo extends GetTime{//子类实现code()抽象方法
    public void code(){
        for(int y = 0;y < 1000;y++){
            System.out.println("y");
        }
    }
}

四、接口——interface

1.概述：接口可以看成一个特殊的抽象类，是常量和抽象方法的一个集合，不能包含变量、一般的方法。

2.特点

(1)接口没有构造器

(2)常量和抽象方法的修饰符都是固定的：

　　常量：public static final

　　方法：public abstract

(3)接口定义的是一种未实现的功能，由类来实现(implements)，如：class CC extends DD implements AA

(4)实现接口的类，必须重写接口所有的抽象方法，才可以实例化，否则这个类仍为抽象类

(5)一个类可以实现多个接口

(6)接口与接口之间也可以是继承的关系，而且可以多继承，而类之间的继承只能是单继承的。

五、内部类

1.定义：在类的内部定义类，外面的类叫外部类，里面定义的类叫内部类。

2.分类：成员内部类（定义在类的内部且在方法外的）；局部内部类（声明在方法内的）

3.特点

(1)内部类可以直接调用外部类的成员；外部类访问内部类时，需要创建一个内部类对象来访问内部类

(2)成员内部类相当于类的成员，可以使用各种修饰符（private public protected static final）

(3)创建静态内部类和非静态内部类成员时的区别（见代码）

(4)外部类和内部类的同名变量的使用（见代码）

public class Test{
    public static void main(String[] args){
        //创建静态内部类的对象，可以直接通过外部类调用静态内部类的构造器
        Person.Dog dog = new Person.Dog();
        //创建非静态内部类的对象，必须先创建外部类的对象，通过该对象调用内部类的构造器
        Person p = new Person();
        Person.Bird bird = p.new Bird();

        bird.info();
        bird.setName("杜鹃");
    }
}

class Person{
    String name="韩梅梅";
    int age;
    //成员内部类(非静态的)
    class Bird{
        String name="黄鹂";
        int id;
        public Bird(){

        }
        public void setName(String name){//同名变量的使用
            System.out.println(name);//杜鹃
            System.out.println(this.name);//黄鹂
            System.out.println(Person.this.name);//韩梅梅
        }
        public void info(){
            show();//直接调用外部类的方法
        }
    }
    //静态成员内部类
    static class Dog{

    }
    public void show(){
        System.out.println("我是外部类的show方法");
    }
}

4.局部内部类及匿名内部类的使用

public Comparable getComparable(){//返回值为Comparable这个接口的对象
    //创建一个实现Comparable接口的类：局部内部类
    class MyComparable implements Comparable{

        @Override
        public int CompareTo(java.lang.Object o){
            return ;
        }
    }
    return new MyComparable();//返回一个实现类的对象
}
//使用方法二
public Comparable getComparable1(){
    //返回一个实现Comparable接口的匿名内部类的对象
    return new Comparable(){

        @Override
        public int CompareTo(java.lang.Object o){
            return ;
        }
    }
}