Java面向对象基础知识

1.面向对象

1.1万事万物皆对象

• 在Java语言范畴中，我们都将功能，结构等封装到类中，通过类的实例化，来调用具体的功能结构

  • Scanner,String等
  • 文件，File
  • 网络资源，URL

• 涉及到Java语言与前端Html,后端的数据来交互时，前后端的结构在Java层面交互时，都体现为类、对象。

2.匿名对象

• 匿名对象的使用
  • 理解：我们创建的对象，没有显示的赋给一个变量名，即匿名对象
  • 特征：匿名对象只能调用一次，你在调一次，就是一个新的对象了
  • 使用：

public class Test{
	public static void main(String[]args){
		Phone p=new Phone();//变量名：p
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();
        
        //匿名对象
        new Phone().sendEmail();
        new Phone().playGame();
        
        new phone().price=1999;
        new phone().showPrice();//0.0
        
        
        //PhoneMall mall=new PhoneMall();
        //mail.show(p);
        //匿名对象的使用
        mall.show(new Phone());
	
	}


}
class Phone{
	double price;

	public void sendEmail(){
		System.out.println("发送邮件");
	}
	public void playGame(){
		System.out.println("打游戏");
	}
    public void showPrice(){
		System.out.println("手机价格为："+price);
	}

}
class PhoneMall{
    
    	pubilc void show(Phone phone){
            phone.sendEmail();
            phone.playGame();
            
        }
}

3.封装与隐藏

• 我们程序设计追求“高内聚，低耦合”。
  • 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合：仅对外暴露少量的方法用于使用
• 隐藏对象内部的复杂性，只会外公开简单的接口，便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想。

当我们创建一个类的对象以后，我们可以通过“对象，属性”的方式，对对象的属性进行赋值，这里赋值操作要受到属性的数据类型和存储范围的数据制约。但是除此之外，没有其他制约条件，我们往往需要给属性赋值加入额外的限制条件，这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加；(比如：set)

同时，我们要避免用户再使用“对象，属性”的方式对属性进行赋值，则需要将属性声明为私有的（private）

举例：

public class AnimalTest {
    public static void main(String[] args) {


        Animal a = new Animal();
        a.name="花花";
        a.setAge(1);
       // a.legs=4;//腿的个数

        a.show();
        a.setLegs(6);
        a.show();
    }
}
class Animal{
    String name;
    private  int age;
    //提供关于属性age和set方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private int legs;
    //对于属性的设置
    public  void setLegs(int l){//谁调用这个方法，你就填个l,然后就把l赋给你这个调方法的那个对象的你自己的legs属性
        if(l>=0&&l%2==0){
            legs=l;
        }else {
            legs=0;
            //legs =0;
            //抛出一个异常
        }
    }
    //对属性的获取
    public int getLegs(){
        return legs;
    }
    public void eat(){

        System.out.println("动物进食");
    }
    public void show(){

        System.out.println("name="+name+",age="+age+",leas="+legs);
    }
        }

• 封装性体现

​ 我们将类的属性XXX私有化（private）,同时，提供公共的（public）方法来获取（getXxx）和（setXxx）设置此属性值

get和set方法;互补性，set无返回值，get有返回值；set有形参，get无形参；

​ 封装性的体现：① 如上②不对外暴露私有的方法③单例模式…

3.1 四种权限修饰符

• 封装性的体现，需要权限修饰符来配合

1. Java规定的四种权限（从小到大排列），private、缺省、protected、public

修饰符	类内容	同一个包	不同包的子类	同一个工程
private	yes
缺省(default)	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

对于class的权限修饰只可以用public和default(缺省)。

public类可以在任意地方被访问

default类只可以被同一个包内部的类访问。

2. 4种权限可以用来修饰类及类的内部结构，属性、方法、构造器、内部类
3. 具体的：4种权限可以用来修饰类及类的内部结构，属性、方法、构造器、内部类
4. 修饰类的话只能用：缺省、public

总结：Java提供了4种权限修饰符来修饰类的内部结构，体现类及类的内部结构在被调用时的可见性大小。

4.构造器（构造方法）

• 类的结构之三：构造器（或构造方法、constructor）的使用

​ constructor：建设者

• 构造器的作用：
  • 创建对象
  • 初始化对象属性信息
• 声明
  • 如果没有显示的定义类的构造器，则系统默认提供一个空参的构造器
  • 定义构造器的格式：权限修饰符 类名（形参列表）{}
  • 一个类中定义的多个构造器，彼此构成重载
  • 一旦我们显示的定义了类的构造器之后，系统就不在提供·默认的空参构造器
  • 一个类中，至少要有一个构造器

public person(){
        System.out.println("Person()..........");
    }

5.this关键字

• this可以用来修饰：调用、属性、方法、构造器

• this修饰属性和方法

  • this理解为当前对象 或 当前正在创建的对象

​ 1.在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略“this.”,特殊情况下，如果方法的形参和类的属性同名时，我们必须显示的使用“this.变量”的方式，表明此变量是属性，而非形参。

​ 2.在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用正在创建对象属性或方法。但是，通常情况下，我们都选择省略“this.”,特殊情况下，如果构造器的形参和类的属性同名时，我们必须显示的使用“this.变量”的方式，表明此变量是属性，而非形参。

​ 3.this调用构造器

​ ①我们在类的构造器中，可以显示使用“this（形参列表）”方式，调用本类中指定的其他构造器

​ ②构造器中不能通过“this（形参列表）”方式调用自己

​ ③如果一个类中有N个构造器，则最多有n-1构造器中使用了“this（形参列表）”

​ ④规定：“this（形参列表）”必须声明当前构造器的首行

​ ⑤构造器内部：最多只能声明一个“this（形参列表）”，用来调用其他的构造器

//对象
public class PersonTest {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(1);
        System.out.println(p.getAge());

        Person p1 = new Person("刘",21);
        System.out.println(p1.getAge()+" "+p1.getName());


    }
}

//类
public class Person {
    private  String name;
    private  int age;
    public Person(){
        System.out.println("我是第一个构造器");
    }
    public Person(String name,int age){
        this();//调用上个构造器
        this.age=age;
        this.name=name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

6.static关键字

• static:静态的
• static可以用来修饰：属性、方法、代码块、内部类
• 使用static修饰属性：静态变量（类变量）

​ 属性：按是否使用static修饰，又分为：静态属性 vs 非静态属性（实例变量）

​ 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改

​ 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

​ static修饰属性的其他说明

​ ①静态变量随着类的加载而加载。

​ ②静态变量的加载要早于对象的创建。

​ ③由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中。

​

	类变量	实例变量
类	yes	no
对象	yes	yes

class Chinese{
    String name;
    int age;
    static  String nation;
}
class Test {
    public static void main(String[] args) {
        Chinese c = new Chinese();
        c.name="姚明";
        c.age=40;
        c.nation="chn";
        Chinese c1 = new Chinese();
        c1.name="马龙";
        c1.age=30;
        c1.nation="CHINA";

        System.out.println(c.age);
        System.out.println(c.name);
        System.out.println(c.nation);

    }
}

6.1类变量实例变量内存解析

• 使用static修饰方法

  • 随着类的加载而加载，可以通过“类.静态方法”的方式进行调用

  • 	静态方法	非静态方法
    类	yes	no
    对象	yes	yes

  • 静态方法中只能调用静态的方法或属性

  • 非静态方法中，即可以调用非静态的方法或属性，也可以调用静态的方法或属性；

• staic注意点

  • 在静态的方法内，不能使用this关键字，super关键字；
  • 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

• 开发中，如何确定一个属性是否要声明为static的？

  • 属性是可以被多个对象所共享的，不会随着对象的不同而不同；

• 开发中，如何确定一个方法是否要声明为static的？

  • 存在静态属性的方法，通常设置为static
  • 工具类中的方法习惯上声明为静态方法，因为没有必要造对象调用