类以及对象，面向对象基本思想——封装，继承

类：

一种描述对象特征和行为的模版，可看做数据结构（组织/存储数据的特定方式）包含了数据成员和对这些数据成员进行操作的方法成员。

类的定义，类名，方法，可通过实例化类来创建对象。

对象：

类的实例，类的具体化。一个对象可以看做一个独立的个体，拥有自己的属性和方法，并且可以与其他对象进行交互和通信。

一个类可创建多个对象，每个对象皆独立。

实例化：

通过一个类创建一个对象的过程，在实例化过程中，需要使用该类的构造函数来初始化对象，并为其指定属性的初始值。

属性（成员变量）：

是类的一个组成部分，一般是数据类型，也可以是引用类型（对象，数组）。如：int age

如果不赋值，有默认值，规则和·数组一致。

java存储方式

1）栈： 一般存放基本数据类型(局部变量)

2）堆： 存放对象(Cat cat , 数组等)

3）方法区：常量池(常量，比如字符串)， 类加载信息

4）示意图 [Cat (name, age, price)]

在Java中，当你声明一个数组时，使用的是 a 这样的语法，而在传递数组作为参数时，只需要传递数组名字 a 即可。pop（a）

方法重载：

方法重载是指一个类中定义多个同名的方法，但要求每个方法具有不同的参数类型或者参数个数。

特点： 1、在同一个类中 2、方法名相同 3、参数个数或者类型不同 4、方法的返回值不能作为判断方法是否构成重载的依据

举例代码

public class Object01{
	public static void main(String[] args){
	Cat cat1=new Cat();//Cat cat为声明对象，cat=new Cat();为创建对象
	cat1.name="小白";
	cat1.age=3;
	cat3.color="白色";
	Cat cat2=new Cat();
	cat2.name="小花";
	cat2.age=100;
	cat2.color="花色";
	System.out.println("第一只猫"+cat1.name+""+cat1.age+""+cat1.color);
	System.out.println("第二只猫"+cat2.name+""+cat2.age+""+cat2.color);
	}
}
class Car{                 //类
	String name;           //属性（对象）
	double age;
	String color;
}

   ​

面向对象基本思想

封装

封装是把过程和数据包装起来，对数据的访问只能通过已定义的接口

1.对数据（属性）的封装使用private

2.对过程（行为）的封装使用，给出访问权限为public的setter(给数据赋值，不需要返回值）方法和getter（获得赋值后的数据，需要返回值）方法

package Fengzhuang;
​
public class Main {
    public static void main(String[] args) {
        Grilfriend girl= new Grilfriend();
        girl.setAge(19);
        girl.setName("小花");
        girl.setGender('女');
        System.out.println("姓名:"+girl.getName()+"\n"+"性别:"+girl.getGender()+"\n"+"年龄:"+girl.getAge());
    }
}
​
package Fengzhuang;
​
public class Grilfriend {
    private int age;
    private String name;
    private char gender;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int a) {
            if(a>0&&a<100){
                age=a;
        }else{
            System.out.println("年龄不符合要求");
        }
    }
​
    public char getGender() {
        return gender;
    }
​
    public void setGender(char gender) {
        this.gender = gender;
    }
}

修饰符

访问修饰符：

public：该类或非该类均可以访问

private：只有该类可以访问

protected：该类及其子类的成员可以访问，同一个包中的类也可以访问

默认：同一个包中的类也可以访问

构造器

1.方法名必须与类名相同，构造方法没有返回值类型声明。

2.使用new关键字实例化对象的时候会自动调用构造方法。

3.Java语言中，每个类至少有一个默认的构造方法。一旦显示的定义了构造方法，系统将不会提供默认的构造方法。

this关键字

作用：用来访问类成员变量，用于区分类成员变量和局部变量（方法体中的变量）

代码：构造器和this

public class Gzq {
    public static void main(String[] args){
        Dog dog1=new Dog();               //调用无参构造器（创建对象时没有传入参数）
        dog1.fun1();                      //调用方法fun1
        Dog dog2=new Dog("小七",6);       //调用有参构造器（创建对象时传入了参数）
        dog2.fun2();                      //调用方法fun2
    }
}
    class Dog{
        String name;
        int age;
        public Dog(String name,int age){     //有参构造器
            this.name=name;（当形参里的变量名和最开始定义的变量名相同时，必须用this）
            this.age=age;
        }
        public Dog(){              
            this.age=3;
        }//这个无参构造方法会在没有参数的情况下被调用，即在创建Dog对象时不传入参数时被调用。在这个无参构造方法中，将狗的年龄初始化为3
        public void fun1(){
            System.out.println("狗1的名字是"+name+"\t"+"年龄是"+age);
        }
        public void fun2(){
            System.out.println("狗2的名字是"+name+"\t"+"年龄是"+age);
        }
    }

运行结果：    
狗1的名字是null  年龄是3
狗2的名字是小七    年龄是6

继承

子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

注意:

子类不能选择性继承父类； Java不支持多重继承，但一个类可以实现多个接口，从而克服单继承的缺点； 构造方法不会被子类继承，但可以从子类中调用父类的构造方法。

重写

当一个子类中一个实例方法具有与其父类中的一个实例方法相同的名称、参数个数，类型和返回值时，称子类中的方法“重写”了父类的方法。

class A{
    public void sayHello() {                      //输出英文欢迎
        System.out.println("Hello,Welcome to Java!!!");
    }
    public void sayBye() {
        System.out.println("GoodBye,everyone");
    }
}
class B extends A {                   //继承（固定格式：class 子类名extends父类名）
    public void sayHello() {          //重写 输出中文欢迎  
        System.out.println("大家好，欢迎学习Java！！！");
    }
}
public class myfirst {
    public static void main(String[] args) {
    B b=new B();                              //创建子类B的一个实例对象，使用默认构造方法
    b.sayHello();                             //调用子类中重写的方法
    b.sayBye();                               //调用父类中的方法
    }
}

super

代表父类的引用，用于访问父类的属性、方法、（不能访问父类的private属性、方法）构造器【super（参数列表)；只能放在构造器的第一句，只能出现在第一句】

（1）当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过supper。

代码

public class Animal {
    public int age;
    public String name;
    public char gender;
    public void action(){
        System.out.println("动物的共同行为是睡觉");
    }
    public Animal(){
    
    }
    public Animal(int age,String name,char gender){
        this.age=age;
        this.name=name;
        this.gender=gender;
    }
}
​
class Dog extends Animal{                  //继承
    String food;
    public Dog(int age,String name,char gender,String food){
        super(age,name,gender);               //访问父类中的属性
        this.food=food;
    }
    public void action(){                     //重写
        System.out.println("狗狗守护主人，会游泳，会看门");
    }
}
class Cat extends Animal{              //继承
    String color;
    public Cat(int age,String name,char gender,String color){
        super(age,name,gender);        //访问父类中的属性
        this.color=color;
    }
    public void action(){           //重写
        System.out.println("猫会抓老鼠，猫猫很可爱，会说话的汤姆猫");
        super.action();             //调用父类中的方法
    }
    
    
    
    public class Main {
    public static void main(String[] args) {
        Dog dog=new Dog(17,"cy",'母',"鸡腿");
        Cat cat =new Cat(19,"yyf",'母',"褐色");
        System.out.println("狗的信息："+"\t"+"名字："+dog.name+"\t"+"年龄："+dog.age+"\t"+"性别："+dog.gender+"\t"+"爱好的食物为"+dog.food);
        System.out.println("猫的信息："+"\t"+"名字："+cat.name+"\t"+"年龄："+cat.age+"\t"+"性别："+cat.gender+"\t"+"喜欢的颜色为"+cat.color);
        dog.action();
        cat.action();
    }
}
​

运行结果：
狗的信息：   名字：cy   年龄：17   性别：母    爱好的食物为鸡腿
猫的信息：   名字：yyf  年龄：19   性别：母    喜欢的颜色为褐色
狗狗守护主人，会游泳，会看门
猫会抓老鼠，猫猫很可爱，会说话的汤姆猫
动物的共同行为是睡觉

super和this的比较