47.【Java 基础之面向对象】

（一）、面向对象:

1.概念:

面向对象是一种思想，能让复杂问题简单化，程序员不需要了解具体的实现过程，只需要指挥对象去实现功能。（类为图纸，对象为实体）

2.面向对象学什么？

1）、学习获取已有对象并使用. （l聊天，手机）
2）、学习如何自己设计对象. （不会飞，飞机）

(二)、类和对象 :

类: 是对象共同特征的描述
对象: 是真实存在的具体东西

1.类格式:

public class 类名{
	成员便零
	成员函数
	构造器
	代码块
	内部类
}
1
2
3
4
5
6
7

2.类对象定义的格式：

类名 类对象 =new 类名();
1

3.类方法的定义

修饰符 数据类型 变量名 （）{}；
1

4.类和类对象的连用

1.创建同一个包中的类:

package test;

public class Phone {    //创建类phone
String brand;
double price;
public void call() {System.out.println("打电话");}
public void playgame() {System.out.println("打游戏");}
}
1
2
3
4
5
6
7
8

2.创建类对象和引用类对象

package test;  //  包名
import java.util.Scanner;
 public class test1 {     //项目名
	public static void main(String []avgs)
	{
		Phone p=new Phone();
		p.brand="华为";    //引用数据成员
		p.price=2103;  
		p.call();          //饮用方法
		p.playgame();
	}
 }
1
2
3
4
5
6
7
8
9
10
11
12

5.总结

1.定义类的建议:

1). 类名首字母建议大写，英文、有意义。满足驼峰模式。不能用关键字，满足标识符规定；
2）.一个代码中可以定义多个类，但是只能一个类是public修饰的，public修饰的类名必须是Java代码的文件名称.
eg:

2.成员的格式是什么样的，有什么特点

1).成员变量的完整定义格式是: 权限修饰符 数据类型 变量名称=初始化值；

     int brand  //不加权限修饰符默认是主方法的权限
1

eg:
主方法:

package test;  //  包名
import java.util.Scanner;
 public class test1 {     //项目名
	public static void main(String []avgs)
	{
		Phone  p=new Phone();
		p.setBrand("华为");
		p.setPrice(2999);
		System.out.println(p.getBrand());
		System.out.println(p.getPrice());
	}
 }
 
1
2
3
4
5
6
7
8
9
10
11
12
13

类方法:

package test;
public class Phone {
	private String brand;
	private double price;
	 public void setBrand(String b)
	 {
		 brand=b;
	 }
	 public String getBrand ()
	 {
		 return brand;
	 }
	 public void setPrice(double p)
	 {
		 price=p;
	 }
	 public double getPrice()
	 {
		 return  price;
	 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2).一般无需指定初始化值.

3.权限修饰符

**private 😗*权限修饰符
1)、可以用来修饰成员（成员变量和成员方法）。
2)、被private修饰的成员只能在本类中才能被访问。
3)、针对private修饰的成员变量，如果需要被其他类使用，需要提供被公有权限修饰的方法.💕
eg:
主方法:

package test;  //  包名
import java.util.Scanner;
 public class test1 {     //项目名
	public static void main(String []avgs)
	{
		Phone  p=new Phone();
		p.setBrand("华为");
		p.setPrice(2999);
		System.out.println(p.getBrand());
		System.out.println(p.getPrice());
	}
 }
1
2
3
4
5
6
7
8
9
10
11
12

调用类:

package test;

public class Phone {
	private String brand;
	private double price;
	 public void setBrand(String b)
	 {
		 brand=b;
	 }
	 public String getBrand ()
	 {
		 return brand;
	 }
	 public void setPrice(double p)
	 {
		 price=p;
	 }
	 public double getPrice()
	 {
		 return  price;
	 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（三）、面向对象的三大特征:

面向对象的三个基本特征是：封装、继承、多态。封装最好理解了。
1).封装是面向对象的特征之一，是对象和类概念的主要特性。
(对象代表什么，就的封装对应的数据，并提供数据的行为)
告诉我们，如何正确的设计对象的属性和方法

假如说：耗牛把吉士先生给KO了，那么请问凶手是谁呢？
答案就是:吉士先生自己ko的，法律判决书上也会写耗牛持触角把吉士先生给整死的，在这里耗牛也就是调用了吉士先生凉凉的方法。在这里对象是吉士先生，我们就的封装吉士先生的数据和行为.

2).面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

3).多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

（四）、this指针

背景:因为根据阿里巴巴JAVA开发手册，我们应该见名示意，所以我们在方法中给数据变量赋值的时候，我们应该使用和数据变量同名的变量名。但是如果使用同名变量名的话，就相当于把自己赋值给自己，就会默认为空值，达不到我们想要的结果。所以此时我们要用this指针来调用.
如果全局变量和局部变量同名的时候，局部里面的先调用局部里面的变量.

this. 同名数据变量========== 调用全局数据变量

（五）、构造方法

1.什么是构造方法：

用来个数据变量赋初始值的方法，叫做构造方法。

2.构造方法的格式:

publci class Student{
	权限修饰符 类名（参数）{方法体}
}
1
2
3

3.执行时机:

1.创建对象的时候由虚拟机调用，不能手动调用构造方法
2.每创建一次对象，就会调用一次构造方法.
3.如果我们没有定义构造函数，虚拟机会自动生成一个无参构造函数

4.具体实战

类方法:

package test;
public class Phone {
	private String brand;
	private double price;
	Phone(){System.out.println("无参构造方法");}   //无参构造
	Phone(String brand,double price){this.brand=brand;this.price=price;}
	  void setBrand(String brand)
	 {
		 this.brand=brand;
	 }
	  String getBrand ()
	 {
		 return brand;
	 }
	  void setPrice(double price)
	 {
		this. price=price;
	 }
	  double getPrice()
	 {
		 return  price;
	 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

主方法:

package test;  //  包名
import java.util.Scanner;
 public class test1 {     //项目名
	public static void main(String []avgs)
	{
		Phone  p=new Phone();//会默认调用无参
		Phone p1=new Phone("VIVO",3999);
		p.setBrand("华为");
		p.setPrice(2999);
		System.out.println(p.getBrand());
		System.out.println(p.getPrice());
		System.out.println("============================");
		System.out.println(p1.getBrand());
		System.out.println(p1.getPrice());
	}
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5.构造方法注意事项:

1.构造方法的定义:
😊如果没有定义构造函数，系统将会给出一个默认的无参构造方法.
😊如果定义了构造放啊，系统将不会调用一个默认的无参构造方法
2.构造方法的重载:
❤带参构造方法，和无参构造方法，两者方法名相同，但是参数不同，这叫构造方法的重载.
3.推荐使用:
无参和有参都要写.

(六)、标准JavaBean类

1.类名需要见名知意
2.成员变量用Private
3.构造函数提供两个: 无参构造函数，有参构造函数
4.成员方法： 提供每个成员变量对应的Set(){} Get(){}

(七)、Java内存分配:

方法区: 字节码文件加载时进入（内存）方法区 .class文件（第一步）
堆区：new 关键字引导的东西，在这块开辟地址.
栈区：方法运行时所进入的内存，包括变量（第二步）

1.对象内存分配的七步：

1.1加载class文件

1.2申明局部变量

1.3在堆内存种开辟一个空间

1.4默认初始化

1.5显示初始化

1.6构造方法初始化

1.7将堆内存的地址赋值给栈内存

一个对象的内存:.

this的本质：代表方法调用者的地址值（区分局部变量和成员变量）

比如以上来说的: 当类对象调用method方法的时候，局部变量首先被println调用，然后this 的本质是代表调用者的地址

（八）、类的继承;

1.类对象继承的格式:

**权限修饰符 class 派生类名 extrens 父类名（）{}**
1

2.派生类构造函数对基类的赋值

权限修饰符 构造函数名（基类成员变量 基类成员变量，派生类成员变量）
{
	super(基类成员变量 基类成员变量)
	this.派生类成员变量=派生类成员变量.
}
1
2
3
4
5

3.派生类同名函数，会对基类造成覆盖.

学生类:

public class  Student extends Person {
    private int id;
    private String  name;

    public Student() {
    }

   public Student(int age,String sex,int id,String name){
        super(age,sex);    //调用父类的构造函数
        this.id=id;
        this.name=name;
   }
   public void setId(int id){
        this.id=id;
   }
   public  int getId(){
        return id;
   }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println(name+" "+id);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

preson类:

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

    public Person() {
    }

    public Person(int age, String sex) {
        this.age = age;
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    public void show(){
        System.out.println(age+" "+sex);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

主函数:

import java.util.*;
public class hello {
    public static void main(String[] avgs) {
        Student s=new Student(21,"女",21032115,"李明");
        s.show();
    }
}
1
2
3
4
5
6
7

4.如果想打破覆盖需要super.同名函数()