JAVA类和对象创建

面向对象
学习目标：

1. 理解面向对象的编程思想
2. 理解类与对象的关系
3. 如何创建类与对象

4. 方法重载
   一：什么是面向对象编程(OOP)
   面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种编程思想,它将对象作为问解决问题的基本元素, 利用对象和对象之间的相互作用来设计程序。

   面向对象思想把整个世界看成由各种对象来组成的。这些对象具有属性和行为(方法)。
   面向对象思考问题的方式：
   1.首先考虑在问题域中设计到的对象有哪些
   2.其次考虑这些对象有怎样的特征和功能
   3.最后考虑对象和对象之间的关系
   二、类与对象
   1.对象：用来描述客观事物的一个实体，由一组属性和行为构成
   2.类：类是一个模板，它描述一类对象的行为和状态
   对象的特征-属性：属性是对象具有的各种特征
   对象的行为-方法：行为是对象执行的各种操作
   对象：用来描述客观事物的一个实体，由一组属性和行为构成
   类： 类是模子，定义对象将会拥有的特征（属性）和行为（方法）
   类与对象的关系
   类是抽象的概念，仅仅是模板
   比如说：“人”
   对象是一个你能够看得到、摸得着的具体实体、也称为类的实例（instance）
   三、类与对象的创建
   定义类的语法：
   [访问修饰符] class 类名 {
   //这里放属性和方法的声明
   }
   类中成员变量的定义
   定义成员变量的语法：
   [访问修饰符] 数据类型 成员变量名 [= 初始值];
   成员变量的类型可以使用Java语言中的任何一种数据类型(包括基本类型和引用类型)。
   在定义成员变量时可以对其进行初始化。如果不对其初始化，Java会使用默认的值对其进行初始化。
   成员变量的作用域是整个类体。

回顾-局部变量和成员变量
定义位置：成员变量直接在类中定义；局部变量定义在方法中。
声明赋值：成员变量可以在声明时赋初始值；若不赋值，会有默认初始值，引用类型的值为null；局部变量在使用前需要赋值。
作用域：成员变量在整个类内部都是可见的，所有成员方法都可以使用它，如果访问权限允许，还可以在类外部使用；局部变量仅限于定义它的方法，在该方法外无法访问它。
注意：
1.在同一个方法中，不允许有同名的局部变量。在不同的方法中，可以有同名的局部变量
2.局部变量可以和成员变量同名，并且在使用时，局部变量具有更高的优先级
类中方法的定义
定义方法的语法：
[访问修饰符] 返回值类型 方法名 (参数类型 参数名1,…){
// 这里放方法的具体实现语句
}
对象的产生和使用
怎么根据设计好的类来创建一个对象?
利用new关键词调用类的构造方法(类的一种特殊方法)就可创建该类的一个对象。
构造方法
构造方法的名字和类名相同，并且没有返回值，并且不要加void。
构造方法的作用在于构造并初始化对象。
每个类中都至少包含一个构造方法。
两种构造方法
默认构造方法
带参构造方法
默认构造方法
默认构造方法就是指不带参数的构造方法。
Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个默认的无参构造方法。
如果类中有一个自己编写的构造方法时，编译器就不会为我们再提供那个默认构造方法
四、方法重载
重载(Overloading)
public class Player
{
public void play(歌曲){ //演唱歌曲}
public void play(钢琴){ //弹奏钢琴}
public void play(剧本){ //根据剧本表演}
}
方法重载：同一个类中，方法名相同，参数列表不同（参数类型不同、参数个数不同、参数顺序不同）
学习目标
1.this关键字
2.static关键字
3.封装性
4.继承性
5.super关键字
6.四种访问权限
7.方法重写
一：This关键字
每个类的每个非静态方法(没有被static修饰)都会隐含一个this引用名称，它指向调用这个方法的对象(当前对象)。
当在方法中使用本类的非static属性时，都会隐含地使用this名称。
this可以看作是一个变量，它的值就是当前对象的引用
this关键字-用法一：
当类中某个非静态方法的参数名跟类的某个成员变量名相同时，为了避免参数的作用范围覆盖了成员变量的作用范围，必须明确地使用this关键字来指定成员变量
this关键字-用法二：
如果某个构造方法的第一条语句具有形式this(...)，那么这个构造方法将调用本类中的其他构造方法。
二：static关键字
在类中，用static声明的成员变量为静态成员变量，它是该类的公用变量，对于该类的所有对象来说，static成员变量只有一份。
用static声明的方法为静态方法，该方法独立于类的实例，所以也叫类方法。
静态方法中只能直接调用本类中其他的静态成员(变量和方法)。
静态方法中不能使用this和super关键字。
静态成员可以通过类名(不需要实例化)或类的实例去访问。
static静态代码块：
在类中可以使用不包含在任何方法中的静态代码块(static block)，当类被JVM载入时，静态代码块被执行，且只被执行一次。
静态代码块经常用来初始化类的静态成员变量。
static{
// 静态代码块内容
}
三:封装性
封装（Encapsulation）
对外部不可见,隐藏对象的属性和实现细节。
封装的好处：隐藏类的实现细节，让使用者只能通过程序员规定的方法来访问数据，可以方便的加入存取控制语句，限制不合理操作。
继承（extends）
代码的重用
扩展类的功能
多态（Polymorphism）
对象的多态性
封装性体现
类的封装(属性、方法都存在于某个类中)
对字段的封装
1字段设置为私有(private)
2添加get /set 方法
访问修饰符的限制，保证数据的安全
单例设计模式(重要)
1.私有化构造方法

2. 在类的内部实例化该类的对象，
   该类的对象必须是static全局变量。
3. 编写获取该单例对象的static方法。
   “饿汉式”单例模式:当类加载到JVM时，单例对象直接创建；
   “懒汉式”单例模式:当类加载到JVM时，并不直接创建单例对象，用户请求单例对象时(用户需要使用时)，才实例化该单例对象；
   四：继承性
   什么是继承：
   继承是一个类继承另一个类.这个类拥有父类可以被继承的成员。
   继承是面向对象特征之一。
   实现继承的类称为子类也叫派生类,而被继承的类称为父类,也叫超类或基类。
   类的方法和属性可以被继承。
   私有的属性和方法不能被继承。
   构造方法不能被继承。
   继承的好处：实现代码的重用和扩展，模拟现实世界的关系，结构更清晰
   继承具有传递性
   单继承性：
   1.在java中一个类只能有一个父类，这就是Java的“单继承性”。
   2.java.lang.Object类是所有类的父类。
   使用继承
   要继承一个类，可以使用extends关键字，意味着扩展父类的功能。
   类继承的基本语法：
   <modifier> class <name> [extends <superclass> ] {
   <declaration> *
   }
   五:super关键字
   在Java类中使用super来引用父类的成员
   super可用于访问父类中定义的属性
   super可用于调用父类中定义的成员方法
   super(…)可用于在子类构造方法中调用父类的构造方法
   super关键字-示例1：
   使用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);
   }
   }
   super调用父类构造方法
   创建子类对象会先调用基类的构造方法，默认调用基类无参构造方法，
   要调用基类其他带参构造方法，则使用super
   super关键字-示例2：
   使用super调用基类中构造方法：
   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(),则调用父类无参构造，而父类中没有无参构造，编译错误
   六:四种访问权限
   对类中的属性和方法的可见度
   访问修饰符
   private
   protected
   public
   访问权限
   类的访问修饰符
   public：任何包中的类都可以访问该类
   默认值：同一个包中的类可以访问该类
   成员的访问修饰符
   private：只对本身类可见
   默认值：对同一包中的类可见
   protected：对跨包的子类和同一包中的类可见
   public：对一切类可见

注意：访问成员的前提是首先能访问成员所属的类
在Java中，可以在类、类的属性以及类的方法前面加上一个修饰符（modifier），来对类进行一些访问上的控制。
注意: default,public也可以用来修饰一个类,但是protected不能修饰一个类
七:方法重写(override)
当子类继承父类时，可以从父类继承它的属性和方法，如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫做方法的重写(override)
重写规则
重写的注意事项(三要素)：

1. 只能存在于子类和父类之间
2. 子类的方法名称、输入参数和返回值类型完全一致或子类方法返回值类型是父类方法返回值类型的子类。

3. 权限不能比父类方法更加严格。
   注意：重写的前提是先继承了父类的方法。
   方法的重写-示例：
   class Person{
   private String name;
   private int age;
   //省略字段封装方法

   public String getInfo(){
   return “名字:”+name+”年龄:”+age;
   }
   }
   class Student extends Person{
   private String school;
   //省略字段封装方法
   public String getInfo(){
   return “名字:”+getName()+”年龄:”+getAge()+”学校:”+school;
   }
   }
   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成员方法之间才是重写

转载于:https://blog.51cto.com/13507330/2049936