week3学习总结

面向对象

//面向对象是一种思考问题的方式

1.面向对象的思考问题的方式

1.首先考虑在问题域中设计到的对象有哪些
2.其次考虑这些对象有怎样的特征和功能
3.最后考虑对象和对象之间的关系

//面向对象不同于面向过程，他需要你了解你面对的对象的一些属性和行为，然后让他们产生联系，是一种大局观一样的思考方式，类似开车，面向对象是某某开车去某地，面向过程则是某某开车门，插钥匙，启动加速，换挡等等一些细致行为。

2类与对象

1.对象：用来描述客观事物的一个实体，由一组属性和行为构成

 2.类：类是一个模板，它描述一类对象的行为和状态

3.与对象的关系：类是对象的类型，对象是类的实例（instance）

3.类与对象的创建

1.定义类的语法
[访问修饰符]  class  类名 {
     //这里放属性和方法的声明
}

eg:

public class Person {
    String name;        //姓名
    boolean sex;        //性别
    int age;                //年龄
    
    public void speak(String word){  //说话
        System.out.println(name + “说:” + word);
    } 
    public void tread(){  //行走
        System.out.println(“四处走动…”);
    } 
}

2.类中成员变量的定义

定义成员变量的语法：
 [访问修饰符]  数据类型  成员变量名 [= 初始值];
成员变量的类型可以使用Java语言中的任何一种数据类型(包括基本类型和引用类型)。
在定义成员变量时可以对其进行初始化。如果不对其初始化，Java会使用默认的值对其进行初始化。
成员变量的作用域是整个类体。

3成员变量与局部变量

比较	成员变量	局部变量
定义位置	直接在类中定义	定义在方法中
声明赋值	可以在声明时赋初始值；若不赋值，会有默认初始值，引用类型的值为null	在使用前需要赋值
作用域	在整个类内部都是可见的，所有成员方法都可以使用它，如果访问权限允许，还可以在类外部使用	仅限于定义它的方法，在该方法外无法访问它
注意	（1）在同一个方法中，不允许有同名的局部变量。在不同的方法中，可以有同名的局部变量 （2）局部变量可以和成员变量同名，并且在使用时，局部变量具有更高的优先级

对象的产生和使用

（1）利用new关键词条用类的构造方法

eg:Student stu=new Student

stu.name ="XX"

stu.say();//调用之前定义的方法

（2）构造方法
构造方法的名字和类名相同，并且没有返回值，并且不要加void。
构造方法的作用在于构造并初始化对象。
每个类中都至少包含一个构造方法。

俩种构造方法为：默认构造方法（不带参）和带参构造方法

eg:

package overloading;


public class Person {
   String name;
   int age;
   String sex;
   public Person(){       //无参构造方法
  
   }
   
   public Person(String n,int a){       //俩参构造方法
  name=n;
  age=a;
   }
   
   public Person(String n,int a,String s){         //三参构造方法
  name=n;
  age=a;
  sex=s;
   }

//Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个默认的无参构造方法。 如果类中有一个自己编写的构造方法时，编译器就不会为我们再提供那个默认构造方法。

   4.方法的重载（overloading)

方法重载：同一个类中，方法名相同，参数列表不同（参数类型不同、参数个数不同、参数顺序不同）

eg:

package overloading;


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

//构造方法重载
   public Person(){
  
   }
      public Person(String n,int a){
  name=n;
  age=a;
   }
   
   public Person(String n,int a,String s){
  name=n;
  age=a;
  sex=s;
   }
   //方法重载
   public void say(){
  System.out.println("我叫"+name+"，今年"+age+"岁了;性别："+sex);
   } 
}

第二天

学习目标：

1.this关键字
2.static关键字
3.封装性
4.继承性
5.super关键字
6.四种访问权限
7.方法重写

1.this关键字

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

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

eg:

 public Person(String name,int age){
    this();
    System.out.println("调用了两参的构造方法");
    this.name=name;
    this.age=age;

2.static关键字（// 静态成员变量属于类的，对于所有该类的对象是公用的）

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

static静态代码块：

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

3.封装性

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

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

4.继承性

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

好处：实现代码的重用和扩展
模拟现实世界的关系
结构更清晰

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

要继承一个类，可以使用extends关键字，意味着扩展父类的功能。

eg:

//子类

package extendsdemo;


public 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);
}

public int getN() {
return n;
}
}

//父类

package extendsdemo;


public class Father {
int n;


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


public Father(int n) {
this.n = n;
System.out.println("父类带参构造");
}

}
继承测试：\

package extendsdemo;


public class Test {


public static void main(String[] args) {
Child c=new Child();
System.out.println("子类对象的成员变量n是："+c.getN());
}
}

5.super关键字
在Java类中使用super来引用父类的成员
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super(…)可用于在子类构造方法中调用父类的构造方法
eg:

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);
}
}

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

eg:

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()不能同时出现

6.四种访问权限

类的访问修饰符
public：任何包中的类都可以访问该类
默认值：同一个包中的类可以访问该类
成员的访问修饰符
private：只对本身类可见
默认值：对同一包中的类可见
protected：对跨包的子类和同一包中的类可见
public：对一切类可见


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

7.方法重写

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

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


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

eg:class Test{
public static void main(String[] args){
Student stu=new Student();
stu.setName(“小明”);
stu.setAge(20);
stu.setSchool(“千锋”);
Person  p=new Person();
p.setName(“小强”);
p.setAge(1000);
System.out.println(stu.getInfo());
System.out.println(p.getInfo());
}
} 

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

******单例设计模式(重要)

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

eg:

“”饿汉式"

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

// 私有化构造方法，防止外部实例化该类的对象
private HungrySingleInstance(){

}


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

"懒汉式"

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;
}

}