Java学习第三周(2)--面向对象第二天

学习目标：
1.this关键字
2.static关键字
3.封装性
4.继承性
5.super关键字
6.四种访问权限

7.方法重写

一、This关键字

1.定义：每个类的每个非静态方法都会隐含一个this引用名称，它指向调用这个方法的对象(当前对象)。

               this可以看作是一个变量，它的值就是当前对象的引用

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

public class Person {
    String name;
    int age;

}

public Person(String name,int age){

    this.name=name;
    this.age=age;
 }

在本例中，如果不使用this关键字，则会造成歧义，编译软件会提示警告信息

(2)如果某个构造方法的第一条语句具有形式this(...)，那么这个构造方法将调用本类中的其他构造方法。

 public Person(){
    System.out.println("无参构造...");
    }

public Person(String name,int age){
    this();

}

第二个构造方法调用了第一个 无参构造

二、static关键字

1.定义：

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

2.static静态代码块

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

static

{
System.out.println("这是静态代码块中的内容...");
note="备注";
count=2;
System.out.println("初始化后的note的值为："+note);
System.out.println("初始化后的count的值为："+count);
}

三、封装

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

3.封装性体现：

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

public class Student {
    private String name;   // private修饰的属性或方法只能在本类中进行访问

}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

先在类中将成员变量的 访问权限设为私有，在创建get/set方法，为用户使用提供数据出口

四、继承
1.定义：

(1)继承是一个类继承另一个类.这个类拥有父类可以被继承的成员
(2)继承是面向对象特征之一
(3)实现继承的类称为子类也叫派生类,而被继承的类称为父类,也叫超类或基类（继承具有传递性）

(4)类的方法和属性可以被继承:私有的属性,方法,构造方法不能被继承

2.好处：代码的重用，扩展类的功能，模拟现实世界的关系，结构更清晰

3.单继承性

(1)在java中一个类只能有一个父类，这就是Java的“单继承性”。
(2)java.lang.Object类是所有类的父类。

4.类继承的基本语法：(修饰符)  class  类名 extends  继承的类名{

                                     //代码

                                  } 

意味着扩展父类的功能

public class Father {
public int n;

}

public class Child extends Father {

}

Child类继承了Father类中声明的公开成员变量，简化了自身的定义

五、super关键字（类似this）

1.定义：在Java类中使用super来引用父类的成员
(1)super可用于访问父类中定义的属性
(2)super可用于调用父类中定义的成员方法
(3)super(…)可用于在子类构造方法中调用父类的构造方法：

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

class Father{
public int value=200;
}
class Child extends Father{
public int value;
public void print(){
value=100;
super.value=50;
System.out.println(“value的值”+value);
System.out.println(“super.value的值”+super.value);
}
}

在本例中，Child类调用了所继承类Father类中成员变量的属性

2.注意事项：
(1)当子类和父类都有同名的属性时，在子类中如果要使用父类的属性 super.属性
(2) super只能应用在成员方法和构造方法中，不能应用在静态方法中

(3) 如果在构造方法中使用必须放在第一行

(4) 在构造方法中this()和super()不能同时出现

六、访问权限

1.定义：对类中的属性和方法的可见度
2.访问修饰符(四种，权限从小到大排列依次为)
private，[default]，protected，public

3.类的访问修饰符
public：任何包中的类都可以访问该类
[default]：同一个包中的类可以访问该类

4.成员的访问修饰符
private：只对本身类可见
[default](默认值)：对同一包中的类可见(当未声明访问权限时，默认为此状态)
protected：对跨包的子类和同一包中的类可见
public：对一切类可见

注意：访问成员的前提是首先能访问成员所属的类

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

public class Test{
public static void main(String[] args) {
Person per=new Person();
per.name="风清扬";
        per.age=20;
        System.out.println("姓名为"+per.name+"，年龄为："+per.age);
}
}

在此例中，如果在Test类中调用成员变量sex的属性，则会报错，因为跨类了，而name和 age的访问权限是default，则可正在同一包中不同类之间使用

七:方法重写(override)

1.定义：当子类继承父类时，可以从父类继承它的属性和方法，如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫做方法的重写

2.注意事项(三要素)：

(1) 只能存在于子类和父类之间
(2) 子类的方法名称、输入参数和返回值类型完全一致或子类方法返回值类型是父类方法返回值类型的子类。
(3) 权限不能比父类方法更加严格。

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

区分：如果子类中成员变量、静态变量、静态方法 和父类中成员变量、静态变量、静态方法相同，这种情况不是重写，可以认为是隐藏，只有非static成员方法之间才是重写

补充：单例设计模式

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

public class HungrySingleInstance {
// 在该类内部实例化对象
private static HungrySingleInstance single=new HungrySingleInstance();
// 私有化构造方法，防止外部实例化该类的对象
private HungrySingleInstance(){
}
// 静态方法，获取单例对象
public static HungrySingleInstance getSingleInstance() {
return 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;
}
}