7.17 Java基础-类-方法-继承-多态

一、方法：有无参数，有无返回值，构造函数

无参构造函数：写了无参构造函数，那么程序在运行的时候会自动调用自己写的无参构造函数，如果没有写，在程序运行的时候会自动添加上无参构造函数。

但是有例外情况

构造方法创建方法：

手写
自动生成 alt+shift+s

注意：当创建了有参构造函数，最好带上无参构造函数，因为创建了有参构造函数之后，程序就不会自动生成无参构造函数。

变量:

局部变量：
在方法中声明的变量称之为局部变量
作用域：方法内部从声明开始到本方法结束（先声明后使用）
类变量：
在类中声明的变量
作用域：整个类中都可以访问

约定>配置>编码

职业分类：开发前端 ui 后台测试维护运维实施 dba 优化

局部变量和类变量的优先级：

一个方法中既有局部变量，又有类变量，当变量名相同时，则优先级：局部变量>类变量。
如果想要调用类变量，需要加 this 关键字。
this: 本类的变量和方法

方法传参

基本类型传参
byte,short,int,long，char,boolean,float,double
基本类型传参，传的是值，两个变量没有任何关系，只是值的传递。
引用类型传参
传递的是对象的地址

注意：只要不是基本类型传参，都是引用类型传参

//Student.java
import java.util.Scanner;import javax.print.attribute.standard.Sides;public class Student {
//  属性String name;  //姓名int age;        //年龄int weight;     //体重//  程序在运行的时候，jvm会自动补充一个无参构造参数，有些情况必须写//   无参构造方法public Student() {}public Student(String name,int age,int weight) {
//      把局部变量的值赋值给类变量this.age =age;this.name = name;this.weight =weight;}//方法public void study() {System.out.println(name+"正在学习");}// 计算两个数的和
//  有参数无返回值public void add(int n1,int n2) {int result = n1+n2;System.out.println("求和，结果是："+result);}public void add2() {Scanner input=new Scanner(System.in);System.out.println("输入第一个数字：");int n1 = input.nextInt();System.out.println("输入第二个数字：");int n2 = input.nextInt();int result = n1+n2;System.out.println("求和，结果是："+result);}// 有返回值public int add3(int n1,int n2) {int result = n1+n2;return result;}}

//Test.java
public class Test {public static void main(String[] args) {// TODO Auto-generated method stub//     根据模板 创建两个对象（实例化）
//      创建第一个对象Student stu1=new Student();
//      赋值 给对象的name属性赋值stu1.name="小王";
//      给对象的另外两个属性赋值stu1.age=20;stu1.weight=60;System.out.println("该对象的名字是："+stu1.name);System.out.println("该对象的年龄是："+stu1.age);System.out.println("该对象的体重是："+stu1.weight);
//      调用对象的方法stu1.study();System.out.println("---------------------------------");
//      再创建一个对象Student stu2=new Student();
//      赋值 给对象的name属性赋值stu2.name="小张";
//      给对象的另外两个属性赋值stu2.age=21;stu2.weight=65;System.out.println("该对象的名字是："+stu2.name);System.out.println("该对象的年龄是："+stu2.age);System.out.println("该对象的体重是："+stu2.weight);
//      调用对象的方法stu2.study();}}

//Test2.java
public class Test2 {public static void main(String[] args) {// TODO Auto-generated method stub//        必须实例化对象才可以调用方法Student student = new Student();//       传参student.add(2, 6);//      调用的方法有返回值，所以需要一个变量来接收int result = student.add3(4, 5);System.out.println(result);}}

//Test4.java
public class Test4 {public static void main(String[] args) {// TODO Auto-generated method stub//        实例化对象Student stu = new Student();
//      此时没有有效值//       给对象的属性赋值stu.name = "12dasd";stu.age = 12;stu.weight = 65;System.out.println(stu.name);//       调用有参构造方法Student stu1 = new Student("dsad", 18, 60);System.out.println(stu1.name);}public void method1() {
//      局部变量   作用域，从声明开始到本方法结束
//      System.out.println(money);
//      int money;}}

//Test5.java
public class Test5 {public static void main(String[] args) {// TODO Auto-generated method stubDog dog = new Dog();
//      dog.print();
//
//      Penguni penguni =new Penguni();
//      penguni.print();}
}

二、对象数组

方法重载：在同一个类中，方法名一样，方法参数不一样。这种现象称之为方法重载（只知道有这种情况就行了）。
参数不一样:包含了参数的个数和位置0
一个方法的参数个数是一个，另一个方法的参数个数是两个，是重载。参数个数相同，例如：public void a(int a,double b) 和 public void a(double b，int a) 也是重载。

面向对象三大特征：封装、继承、多态

//Student.java
public class Student {//    静态变量  全局变量public static String tel;private int age;  //年龄 private String name;public Student() {super();}public Student(int age, String name) {this.age=age;this.name=name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}}

//Test.java
public class Test {//   求和方法public void calc1(int num) {num=num+1;System.out.println("num:"+num);}//   求和public void calc2(Student student) {
//      student.age++;int age = student.getAge();age++;student.setAge(age);System.out.println("student.age:"+student.getAge());}}

//Test1.java
public class Test1 {public static void main(String[] args) {// TODO Auto-generated method stub//        创建对象Student stu1 = new Student(21, "dssds");Student stu2 = new Student(22, "dssd");Student stu3 = new Student(23, "dss");//        把对象放到数组中//      创建数组Student[] stus = new Student[3];//     向数组中添加内容stus[0] = stu1;stus[1] = stu2;stus[2] = stu3;//      1.输出所有学生的姓名for (int i = 0; i < stus.length; i++) {
//          stus[i]:数组的地i个元素 是个对象System.out.println(stus[i].getName());}//      2.统计学生的平均年龄int sum = 0;double ave = 0;for (int i = 0; i < stus.length; i++) {sum+=stus[i].getAge();}ave = (double)sum/stus.length;System.out.println("学生的平均年龄为："+ave);}}

//Test2.java
public class Test2 {public static void main(String[] args) {// TODO Auto-generated method stubint num = 100; //局部变量Test test =new Test();test.calc1(num);System.out.println(num);Student student = new Student();student.setAge(18);
//      传参test.calc2(student);System.out.println(student.getAge());}}

//test3.java
public class Test3 {public static void main(String[] args) {// TODO Auto-generated method stub
//      Student s = new Student();先实例化对象再访问
//      System.out.println(s.tel);//        当定义成静态变量后   类名.属性名  访问静态变量String string = Student.tel;}}

三、封装

封装：不能直接访问，需要用过特定的方式访问，保证数据的安全。

封装步骤：

属性私有化关键字：private 私有的所修饰的属性只能在本类中访问
给属性添加对应的get/set方法，让外界只能通过get/set方法来操作属性
get:获取属性值
set:给属性赋值

Static：所修饰的属性和方法可以直接通过类名来访问
局部变量、类变量
全局变量又称为静态变量

为什么可以直接类名.属性名可以直接访问？

static所修饰的属性和类的属性加载时间不一样。
成员变量初始化实在对象实例化之后进行的，先实例化对象，后初始化类变量。
static所修饰的实行或者方法会在程序运行的时候就被加载和初始化。

三、继承

继承
A excends B
那么A可以调用B的属性和方法

方法重写：父类与子类中，方法名和参数列表一样

为什么要进行方法重写？
有时候父类的方法不能满足子类的个性化要求，此时就需要用到重写

//父类 Pet.java
public class Pet {private String name;      //名字private int health;     //健康值private int love;      //亲密度public Pet() {super();System.out.println("父类的无参构造函数");}public Pet(String name, int health, int love) {super();this.name = name;this.health = health;this.love = love;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getHealth() {return health;}public void setHealth(int health) {this.health = health;}public int getLove() {return love;}public void setLove(int love) {this.love = love;}public void print() {System.out.println("这是一只宠物");}}

//子类 Dog.java
public class Dog extends Pet {private String strain;//  在无参的构造函数中，super()写不写都会调用父类的无参构造函数public Dog() {super();//访问父类的无参构造函数 必须在方法的第一行// TODO Auto-generated constructor stub
//      super不可以访问父类私有的属性和方法System.out.println("dog子类的无参构造函数");}
//  访问父类的有参构造函数public Dog(String name, int heath, int love,String strain) {
//      为什么必须在第一行
//      实例化的时候，把必须先实例化父类，才可以实例化子类
//      先有父，再有子super(name, heath, love);// TODO Auto-generated constructor stubthis.strain = strain;}// 重写父类的方法，在调用的时候 优先调用自己的方法@Overridepublic void print() {System.out.println("这是一只宠物狗");}}

//子类 Penguni.java
public class Penguni extends Pet {private String sex;public Penguni() {super();// TODO Auto-generated constructor stub}@Overridepublic void print() {System.out.println("这是一只宠物企鹅");}
}