java面向对象----1

一、面向对象思想

1、面向对象思想介绍

（1）、面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做事。

//例：把大象装进冰箱
/*人{
    打开(参数：冰箱){
      调用功能
      冰箱.开();
    }
    抬起（大象）{
      调用功能
    }
    关闭（冰箱）{
    }
}
大象{
  进冰箱（）{
  }
}
冰箱{
   打开（）{}
   关闭（）{}

}
*/

2、面向对象的两个要素

类：对一类事物的描述，是抽象的、概念上的定义。
对象：是实际存在的该类事物的每个个体，因而也称为实例。

二、类和对象的使用

1、创建类、设计类的成员

//创建Person类
class Person{
    //属性
    String name;
    int age = 1;
    boolean isMale;
    //方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void say(String la){
        System.out.println("语言" + la);
    }
}

2、创建类的对象

public class MianDuiXiang {
    public static void main(String[] args) {
        //创建Person类的对象
        Person p1 = new Person();
    }
}

3、调用对象的结构

public class MianDuiXiang {
    public static void main(String[] args) {
        //创建Person类的对象
        Person p1 = new Person();
        //调用类的结构：对象.属性
        p1.age = 10;
        p1.name = "wo";
        System.out.println(p1.name);
        //调用方法：对象.方法
        p1.eat();
        p1.say("ch");//传入参数
        //如果创建了一个类的多个对象，则每个对象都有自己的一套独立的类的属性（非static的）。
    }
}

3、说明

public class MianDuiXiang {
    public static void main(String[] args) {
        //创建Person类的对象
        Person p1 = new Person();
        //调用类的结构：对象.属性
        p1.age = 10;
        p1.name = "wo";
        System.out.println(p1.name);
        //
        Person p2 = p1;
        //将p1的地址赋给p2，p1和p2指向同一个对象实体。
        
    }
}

三、类的设计

1、类中属性的使用

属性（成员变量）和局部变量的比较

（1）、相同点
①定义变量的格式：数据类型 变量名 = 变量值;
②先声明后使用
③都有作用域
（2）、不同点
①属性：直接定义在{}内的
局部变量：声明在方法内、方法形参、代码块、构造形参、构造器内部的变量。
②权限修饰符的不同
属性：可以使用权限修饰符(如public等)
局部变量：不可以使用权限修饰符
③默认初始化值
属性：有默认初始化值。
局部变量：没有默认初始化值。
④内存中加载的位置不同

class Person{
    //属性
    String name;
    int age = 1;
    boolean isMale;
    //方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void say(String la){//形参，局部变量
        System.out.println("语言" + la);
        int a = 1;//局部变量
    }
}

2、类中方法的声明和使用

方法:描述类所具有的功能

方法的分类

方法的声明

声明：权限修饰符 返回值类型 方法名(形参列表){
方法体
}
1、权限修饰符
private、 public、缺、protected
2、返回值类型
①如果方法有返回值，必须在方法声明时，指定返回值类型。同时，方法中，需要使用return关键字返回指定类型的变量和常量。
②如果方法没有返回值，则方法声明时使用void表示。
3、方法名
①遵循命名规范
②见名知意
4、形参列表
①方法可以声明0，1，2，或多个形参
格式：数据类型1 形参1，数据类型2 形参2，数据类型3 形参3…
5、方法体
方法功能的实现
说明
return关键字的使用：
①适用范围：使用在方法体中
②作用：结束方法、针对有返回值类型的方法，返回所要的数据。
③ return关键字后不可以有执行语句。

方法的使用

①可以调用当前类的属性或方法
②可以调用自己(递归)
③方法中不可以在定义方法

3、匿名对象的使用

//匿名对象
new Person().say;
//创建的对象没用赋给一个变量值
//匿名对象只能调用一次

4、方法的重载

概念

1、定义：在一个类中，允许存在一个以上的同名方法，只要他们的参数个或数据类型不同。
“两同一不同”：同一个类、同一个方法名、参数列表不同
方法的重载:跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系。

//方法重载
public class Person{
public void sum(int a,int b){
    
}
public void sum(String a,int b){

}
public void sum(int a,String b){

}
}

5、可变个数的形参

(1)、格式：数据类型… 变量名
(2)、当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个或多个

public class Person{
Person to = new Person();
to.sum(1);
to.sum(1,2);
public void sum(int ... a){

}
}

(3)、可变个数的形参在方法的形参中，必须声明在末尾。
(4)、可变个数的形参在方法的形参中，最多只能声明一个可变形参。

6、方法形参的传递机制

(1)、值传递

①形参：方法定义时，声明的小括号内的参数。
实参：方法调用时，实际传递给形参的数据。
②值传递机制：
如果参数时基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数时引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

7、方法递归

递归方法：一个方法体调用自身。

四、面向对象的特性–封装性

1、封装性解释

当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值，赋值操作要受到属性的数据类型和存储范围的制约，除此之外，没有其他限制条件。但是，在实际问题中，我们往往需要给属性赋值，加入额外的限制条件，这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。(例如set和get方法)同时我们需要避免用户使用“对象.属性”的方式对属性进行赋值，则需要将属性声明为私有的(private)-----针对属性体现了封装性

2、修饰符

Java中的四种修饰符(从小到大)：private、缺、protected、public

五、面向对象–构造方法

1、构造方法作用

(1)、创建对象

public class PersonText {
    public static void main(String[] args) {
        //创建类的对象：new + 构造方法
        Person p1 = new Person();
        p1.eat();
    }
}
class Person{
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void say(){
        System.out.println("嗨");
    }
}
//如果没有显示的定义类的构造方法，则系统默认提供一个空参的构造器。

(2)、给对象进行初始化

public class PersonText {
    public static void main(String[] args) {
        //创建类的对象：new + 构造方法
        Person p1 = new Person(5);
        p1.age;//age = 5
    }
}
class Person{
    String name;
    int age;
    //构造方法
    public Person(int i){
        age = i;
    }
}

2、构造方法的定义

格式：权限修饰符 类名(形参列表){}

public class PersonText {
    public static void main(String[] args) {
        //创建类的对象：new + 构造方法
        Person p1 = new Person();
        p1.eat();
    }
}
class Person{
    //属性
    String name;
    int age;
    //构造方法
    public Person(){
    }
    public Person(int i){
        age = i;
    }
    //方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void say(){
        System.out.println("嗨");
    }
}

一个类中定义多个构造方法，彼此构成重载
一旦定义了类的构造方法，系统就不再提供默认的空参构造器
说明
属性赋值的先后顺序(从小到大)
①默认初始化
②显式初始化
③构造方法中赋值
④通过“对象.方法”或“对象.属性”方式赋值

六、关键字

1、this

(1)、this可以用来修饰：属性、方法、构造方法
(2)、this修饰属性和方法时
①this理解为：当前对象
②在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性和方法。通常情况下可以省略，特殊情况下，如果方法的形参和类的属性同名时，我们必须使用“this.变量”的方式，表明此变量是属性，而不是形参。
(3)、this调用构造方法
①在类的构造方法中，可以显示的使用“this.(形参列表)”方式，调用本类中指定的其他构造方法
②构造方法中不能通过“this.(形参列表)”方式调用自己
③“this.(形参列表)”必须声明在当前构造器的首行
⑤构造器内部，最多只能声明一个“this.(形参列表)”调用其他构造器

2、package(包)

(1)、使用package声明类或接口所属的包，声明在源文件首行
(2)、包：属于标识符，遵循命名规则、“见名知意”
(3)、每“.”一次，就代表一层文件目录
(4)、同一包下不能命名同名的接口、类

3、import

(1)、在源文件中显示使用import结构导入指定包下的类、接口
(2)、声明在包的声明和类的声明之间
(3)、如果需要导入多个结构，则并列写出
(4)、可以使用“xxx.*”的方式，表示导入xxx包下的所有结构
(5)、如果使用的类和接口是java.lang包下的定义的，则可以省略import
(6)、如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
(7)、import static：导入指定类或接口中的静态结构：属性和方法