java（6）面向对象（第二天）

声明：由于学习所用环境为JDK1.8,所有有关java代码均在JDK1.8环境下测试通过，如果环境发生变化，可能会有错误产生！

static修饰的方法（静态方法）属于类，非静态方法属于对象，需要通过类实例化对象来调用。

一、THIS关键字

(1)每个类的每个非静态方法(没有被static修饰)都会隐含一个this引用名称，它指向调用这个方法的对象(当前对象)。
(2)当在方法中使用本类的非static属性时，都会隐含地使用this名称。
(3)this可以看作是一个变量，它的值就是当前对象的引用
1、用法一

当类中某个非静态方法的参数名跟类的某个成员变量名相同时，为了避免参数的作用范围覆盖了成员变量的作用范围，必须明确地使用this关键字来指定成员变量。

eg：public class Test {
    String name;
    String sex;
    int age;
 
    public Test(String name, String sex, int age) {
        super();
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

}

2、用法二

如果某个构造方法的第一条语句具有形式this(...)，那么这个构造方法将调用本类中的其他构造方法。
eg：public class Person {
    String name;
    int age;
    String sex;
    public Person(){
        System.out.println("无参构造...");
    }
    
    public Person(String name,int age){
        this();
        System.out.println("调用了两参的构造方法");
        this.name=name;
        this.age=age;
    }
    
    public Person(String name,int age,String sex){
        this(name,age);
        System.out.println("调用了三参的构造方法");
        this.sex=sex;
    }
    
    public void say(){
        System.out.println("我叫"+this.name+"；今年"+this.age+"岁了,性别："+this.sex);
    }
}
测试代码

public class TestThis {

    public static void main(String[] args) {
        Person per=new Person("李丽",20,"女");
        per.say();
    }

}

二、static 关键字

(1)在类中，用static声明的成员变量为静态成员变量，它是该类的公用变量，对于该类的所有对象来说，static成员变量只有一份。
(2)用static声明的方法为静态方法，该方法独立于类的实例，所以也叫类方法。
(3)静态方法中只能直接调用本类中其他的静态成员(变量和方法)。
(4)静态方法中不能使用this和super关键字。
(5)静态成员可以通过类名(不需要实例化)或类的实例去访问。

1、static静态代码块

在类中可以使用不包含在任何方法中的静态代码块(static block)，当类被JVM载入时，静态代码块被执行，且只被执行一次。
静态代码块经常用来初始化类的静态成员变量。
   static{
        // 静态代码块内容
   }

eg：public class StaticBlock {
    
    static String note;
    static int count;
    
    public StaticBlock(){
        System.out.println("无参构造...");
    }
    
    static{
        System.out.println("这是静态代码块中的内容...");
        note="备注";
        count=2;
        System.out.println("初始化后的note的值为："+note);
        System.out.println("初始化后的count的值为："+count);
    }

}

测试代码

public class TestStaticBlock {

    public static void main(String[] args) {
        StaticBlock sb=new StaticBlock();

    }

}
static静态代码块首先被执行，经常用来初始化成员变量中的静态成员变量

三、封装性

(1)对外部不可见,隐藏对象的属性和实现细节。
(2)封装的好处：隐藏类的实现细节，让使用者只能通过程序员规定的方法来访问数据，可以方便的加入存取控制语句，限制不合理操作。

1、封装性的体现

(1)类的封装(属性、方法都存在于某个类中)
(2)对字段的封装
   1字段设置为私有(private)
   2添加get /set 方法
   访问修饰符的限制，保证数据的安全

四、继承性

**继承是一个类继承另一个类.这个类拥有父类可以被继承的成员
**继承是面向对象特征之一
**实现继承的类称为子类也叫派生类,而被继承的类称为父类,也叫超类或基类
**类的方法和属性可以被继承
**私有的属性和方法不能被继承
**构造方法不能被继承
**继承具有传递性

**单继承性：1.在java中，一个类只能有一个父类，但是一个父类可以有多个子类。

                     2.java.lang.Object类是所有类的父类

**类的继承

1、语法：访问修饰符  class 子类名 extends 父类名{

       //代码语句

}

eg:public class Father {
    int n;

    public Father() {
        System.out.println("父类无参构造");
    }

public class Child extends Father {
    public Child() {
        super(300);
        System.out.println("子类无参构造");
    }

五、super关键字

**在Java类中使用super来引用父类的成员
**super可用于访问父类中定义的属性
**super可用于调用父类中定义的成员方法
**super(…)可用于在子类构造方法中调用父类的构造方法
eg1：class Father{
    public int value=200;
}
class Child extends Father{
    public int value;
    public void print(){
        value=10;
        super.value=5;
        System.out.println(“value的值”+value);
        System.out.println(“super.value的值”+super.value);
    }

1、super调用基类构造方法
**创建子类对象会先调用基类的构造方法，默认调用基类无参构造方法，
**要调用基类其他带参构造方法，则使用super
eg2：

Class Father{
    private int n;
    public Father(){
        System.out.println(“父类无参构造”);    
    }
    public Father(int n){
        this.n=n;
        System.out.println(“父类中带参构造”+n);
    }
}
class Child extends Father{
    private int n;
    public Child(){
        super(300);
        System.out.println(“子类无参构造”);    
    }
    public Child(int n){
        this.n=n;
        System.out.println(“子类带参构造”+n);
    }
}
使用super关键字注意事项：
  1 当子类和父类都有同名的属性时，在子类中如果要使用父类的属性用 super.属性
  2 super只能应用在成员方法和构造方法中，不能应用在静态方法中（和this是一样的）
  3 如果在构造方法中使用必须放在第一行
  4 在构造方法中this()和super()不能同时出现
常见错误：

class Father{
    String name;
    public Father(String name){
        this.name=name;
    }
}
class Child extends Father{
    public Child(){
    }
    public Child(String name){
        super(name);
    }
}

子类构造方法中没有super()，则调用父类无参构造，父类没有无参构造方法，编译报错。

2、this和super的对比

六、四种访问权限

1、访问修饰符
private
[default]:包级别访问权限，默认时的访问权限，表示一种状态
protected
public

2、访问权限

**类的访问修饰符
public：任何包中的类都可以访问该类
默认值：同一个包中的类可以访问该类
**成员的访问修饰符
private：只对本身类可见
默认值：对同一包中的类可见
protected：对跨包的子类和同一包中的类可见
public：对一切类可见
注意：访问成员的前提是首先能访问成员所属的类

注意：public，[default]也可以用来修饰一个类，但是protected不能用来修饰一个类。

eg：

package right;

public class Person {
    String name;
    int age;
    protected String sex;
}

package right;

public class TestDefault {

    public static void main(String[] args) {
        Person per=new Person();
        per.name="风清扬";
        per.age=20;
    }

}

package right2;

import right.Person;

public class Student extends Person{
   public void say(){
       // 在子类中可以跨包访问父类的protected属性
       System.out.println("性别是："+this.sex);   
   }
}

package right2;

import right.Person;

public class TestDefault {

    public static void main(String[] args) {
        Person per=new Person();

    }

}

七、方法重写

1、当子类继承父类时，可以从父类继承它的属性和方法，如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫做方法的重写(override)
**重写的注意事项(三要素)：
(1) 只能存在于子类和父类之间
(2) 子类的方法名称、输入参数和返回值类型完全一致或子类方法返回值类型是父类方法返回值类型的子类。
(3) 权限不能比父类方法更加严格。

注意：重写的前提是先继承了父类的方法。
eg：

public class Person {
    public Object getInfo(){
        System.out.println("Person父类的getInfo()方法");
        return "我是父类中的方法";
    }
   

public class Student extends Person{
    
    @Override
    public String getInfo(){
        System.out.println("子类方法");
        return "学生的getInfo()方法";
}

2、重写和重载的对比

方法重写注意事项：

（1）在JDK1.5之后，重写方法的返回值类型可以和父类中的方法返回值类型兼容 （引用类型之间）
（2）如果子类中成员变量、静态变量、静态方法 和父类中成员变量、静态变量、静态方法相同，这种情况不是重写，可以认为是隐藏，只有非static成员方法之间才是重写
八、单例设计模式（重点）

 1.私有化构造方法
  2. 在类的内部实例化该类的对象，
       该类的对象必须是static全局变量。
  3. 编写获取该单例对象的static方法。
 “饿汉式”单例模式:当类加载到JVM时，单例对象直接创建；

eg：

package single;
/*
 * “饿汉式”单例模式:当类加载到JVM时，单例对象直接创建
 * */
public class HungrySingleInstance {
   
    // 在该类内部实例化对象
    private static HungrySingleInstance single=new HungrySingleInstance();
    
    // 私有化构造方法，防止外部实例化该类的对象
    private HungrySingleInstance(){
        
    }

    // 静态方法，获取单例对象
    public static HungrySingleInstance getSingleInstance() {
        return single;
    }
    
    
}

 “懒汉式”单例模式:当类加载到JVM时，并不直接创建单例对象，用户请求单例对象时(用户需要使用时)，才实例化该单例对象；
eg：

package single;
/*
 * “懒汉式”单例模式:当类加载到JVM时，并不直接创建单例对象，用户请求单例对象时(用户需要使用时)，才实例化该单例对象
 * */
public class LazySingleInstance {
   
    // 在该类内部实例化对象
    private static LazySingleInstance single;
    
    // 私有化构造方法，防止外部实例化该类的对象
    private LazySingleInstance(){
        
    }

    // 静态方法，获取单例对象
    public static synchronized LazySingleInstance getSingleInstance() {
        if(single==null){
            System.out.println("第一次访问单例，创建......");
            single=new LazySingleInstance();
        }
        return single;
    }
    
}