面向对象
（一）、面向对象:
1.概念:
面向对象是一种思想，能让复杂问题简单化，程序员不需要了解具体的实现过程，只需要指挥对象去实现功能。（类为图纸，对象为实体）
2.面向对象学什么？
1）、学习获取已有对象并使用. （l聊天，手机）
2）、学习如何自己设计对象. （不会飞，飞机）
(二)、类和对象 :
类: 是对象共同特征的描述
对象: 是真实存在的具体东西
1.类格式:
public class 类名{
成员便零
成员函数
构造器
代码块
内部类
}
2.类对象定义的格式：
类名 类对象 =new 类名();
3.类方法的定义
修饰符 数据类型 变量名 （）{}；
4.类和类对象的连用
1.创建同一个包中的类:
package test;
public class Phone { //创建类phone
String brand;
double price;
public void call() {System.out.println("打电话");}
public void playgame() {System.out.println("打游戏");}
}
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();
}
}
5.总结
1.定义类的建议:
1). 类名首字母建议大写，英文、有意义。满足驼峰模式。不能用关键字，满足标识符规定；
2）.一个代码中可以定义多个类，但是只能一个类是public修饰的，public修饰的类名必须是Java代码的文件名称.
eg:
2.成员的格式是什么样的，有什么特点
1).成员变量的完整定义格式是: 权限修饰符 数据类型 变量名称=初始化值；
int brand //不加权限修饰符默认是主方法的权限
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());
}
}
类方法:
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;
}
}
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());
}
}
调用类:
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).封装是面向对象的特征之一，是对象和类概念的主要特性。
(对象代表什么，就的封装对应的数据，并提供数据的行为)
告诉我们，如何正确的设计对象的属性和方法
假如说：耗牛把吉士先生给KO了，那么请问凶手是谁呢？
答案就是:吉士先生自己ko的，法律判决书上也会写耗牛持触角把吉士先生给整死的，在这里耗牛也就是调用了吉士先生凉凉的方法。在这里对象是吉士先生，我们就的封装吉士先生的数据和行为.
2).面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
3).多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
（四）、this指针
背景:因为根据阿里巴巴JAVA开发手册，我们应该见名示意，所以我们在方法中给数据变量赋值的时候，我们应该使用和数据变量同名的变量名。但是如果使用同名变量名的话，就相当于把自己赋值给自己，就会默认为空值，达不到我们想要的结果。所以此时我们要用this指针来调用.
如果全局变量和局部变量同名的时候，局部里面的先调用局部里面的变量.
this. 同名数据变量========== 调用全局数据变量
（五）、构造方法
1.什么是构造方法：
用来个数据变量赋初始值的方法，叫做构造方法。
2.构造方法的格式:
publci class Student{
权限修饰符 类名（参数）{方法体}
}
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;
}
}
主方法:
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());
}
}
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 父类名（）{}**
2.派生类构造函数对基类的赋值
权限修饰符 构造函数名（基类成员变量 基类成员变量，派生类成员变量）
{
super(基类成员变量 基类成员变量)
this.派生类成员变量=派生类成员变量.
}
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);
}
}
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);
}
}
主函数:
import java.util.*;
public class hello {
public static void main(String[] avgs) {
Student s=new Student(21,"女",21032115,"李明");
s.show();
}
}
