JavaSE （Java基础）：面向对象（上）
8 面向对象
面向对象编程的本质就是：以类的方法组织代码，以对象的组织（封装）数据。
8.1 方法的回顾
package com.oop.demo01;// Demo01 类
public class Demo01 {// main方法public static void main(String[] args) {int c = 10;int d = 90;System.out.println(max(c,d));sayHello();}/*修饰符 返回值类型 方法名(...){// 方法体return 放回值；}*/// return 结束方法，返回一个结果!public static String sayHello(){return "Hello,world";}public static int max(int a,int b){return a>b ? a : b; // 三元运算符；}}如果没有返回值在方法中的话，结果就会如下这段代码所示：
package com.oop.demo01;// 值传递
public class Demo04 {public static void main(String[] args) {int a = 1;// a 的值始终没有改变过都还是1System.out.println(a); // 1change(a);System.out.println(a); // 1}// 返回值为空public static void change(int a){a = 10;}
}
8.2 类与对象的创建、基础使用
关于类的创建就是直接在IDEA中的文件下直接创建类，就是点Java的文件，进行编译以后就是点class的文件。创造对象就是：对象类型 对象名 = 对象值。
我是这样理解的：
类就可以看做一个做蛋糕的模具，而对象就是按照这个模具所做出来的一个个蛋糕，蛋糕可以外表一样，但是名字可以不一样。比如都是用Student这个类来创建对象。却可以有：
Student S1 = new Student();
Student S2 = new Student();
Student S3 = new Student();........................等等
package com.oop.demo01;public class Demo02 {// 静态方法// 非静态方法public static void main(String[] args) {//实例化这个类// 对象类型 对象名 = 对象值Student student = new Student();student.say();}// 有static就是和类一起加载的public static void a(){//c(); -->这里的方法如果调用的话会直接报错。/*因为被static修饰过的方法是和类一起加载的，而他所调用的这个方法没有被static修饰，所以在实例化之后才存在。*/}// 类实例化之后才存在public void c(){}
}
可以在类里面再创建一个类，并且在里面的类里调用其他的类，如下面这段代码：
package com.oop.demo01;// 引用传递：对象，本质还是值传递
public class Demo05 {public static void main(String[] args) {Perosn perosn = new Perosn();System.out.println(perosn.name); // nullchange(perosn); // 调用了方法changeSystem.out.println(perosn.name); // 周某}public static void change(Perosn perosn){// perosn是一个类：指向的---> Perosn perosn = new Perosn();这是一个具体的人，可以改变属性perosn.name = "周某";}
}//定义了一个Perosn类，有一个属性：name
class Perosn{String name; //这里定义了一个name属性，返回值为默认的null
}8.3 构造器
关于构造器：一个类即使什么都不行都会存在一个方法，这个方法是一个没有参数的方法，
当我们创建对象时所使用的new关键字本质上是在调用我们的构造器。
需要注意的是：我们可以定义有参数的构造器，如果定义了他，就需要再一次定义本身已经存在的无参构造器。
package com.oop.demo02;// java ---> class
public class Person {// 一个类及时什么都不写它也会存在一个方法// 显示的定义构造器String name;// 实例化初始值//1. 使用new关键字，本质是在调用构造器//2. 用来初始化值// 无参的构造器public Person(){this.name = "周某";}// 有参构造：一旦定义了有参构造，无参就必须显示定义public Person(String name){this.name = name;}
}
/*
在可执行的类中的代码：
public class AppLication {public static void main(String[] args) {//new 实例化了一个对象Person person = new Person("周鹭巡");System.out.println(person.name); // 周某}
}构造器：1. 和类名相同2.没有返回值作用：1. new 本质在调用构造方法2. 初始化对象的值注意点：定义有参构造之后，如果想使用无参构造，显示定义一个无参的构造*/8.4 封装
关于封装就是在类里面定义属性的时候使用修饰符private，在这个类里面可以定义一些可以操作这个属性的方法，这些方法需要特定的名称。
get元素名 ：获得这个元素的值
set元素名 ：设置这个元素的值
package com.oop.demo04;public class Student {// 属性私有private String name;private int id;private String sex;private int age;// 提供一些可以操作这个属性的方法！// 提供一些public的get、set方法！// get 获得这个数据public String getName(){return this.name;}// set 给这个数据设置值public void setName(String name){this.name = name;}public int getId(){return this.id;}public void setId(int id){this.id = id;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {if (age < 120 && age > 0){this.age = age;} else{this.age = 20;}}
}/*
在可执行类中的代码：public static void main(String[] args) {Student S1 = new Student();S1.setName("周鹭巡");S1.setAge(999);S1.setId(35);S1.setSex("男");System.out.println(S1.getSex());System.out.println(S1.getId());System.out.println(S1.getName());System.out.println(S1.getAge());}封装：1. 提高了程序的安全性，保护数据2. 隐藏代码的实现细节3. 统一接口4. 系统可维护增加了*/8.5 继承、Super
继承就是直接在类名后面跟上关键词extends与父类的名字，子类可以继承父类的所有方法。
Super就是在子类中调用父类中的属性或者父类中的方法。
直接在子类的构造器的代码第一行使用代码super();，就是调用父类的构造器。
Person父类：
package com.oop.demo05;// 在Java中，所有的类，都默认直接或者间接继承Object
// Person 人：父类
public class Person /*extends Object*/ {public Person() {System.out.println("Person无参执行了");}private int money = 10_0000_0000;public void say(){System.out.println("说什么呢？");}public int getMoney() {return money;}public void setMoney(int money) {this.money = money;}protected String name = "zhoumou";// 私有的东西无法被继承public void print(){System.out.println("Person");}
}
Student子类：
package com.oop.demo05;// 学生 is 人： 派生类，子类
// 子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {// Ctrl + Hpublic Student() {// 隐藏代码：调用了父类的无参构造super();//调用父类的构造器，必须在子类构造器的第一行System.out.println("Student无参构造执行了");}public void print(){System.out.println("Student");}public void test1(){print();this.print();super.print();}private String name = "zlx";public void test(String name){System.out.println(name);System.out.println(this.name);System.out.println(super.name);}
}
8.6 方法的重写
我是这么理解的，当创建对象时，类型为这个对象所属的父类时，他所调用的父类引用的方法是指向的子类，就好像儿子不听爸爸话了。
其实方法的重写就是调用方法是，方法的修饰符静态与非静态的区别。
你给别人弄成了静态的话，那么调用时遵循的就是创建对象时左边的数据类型了。
如果是非静态的话，子类就不听父类话了，就都是向子类的方法看齐，你是调用到的父类的方法，但是引用到的确实子类的方法。
可执行类：
public class AppLication{public static void main(String[] args) {//静态的方法与非静态的方法区别很大// 方法的调用只和左边的数据类型有关A a = new A();a.test();// 父类的引用指向了子类B b = new A();b.test();}
}A类：
package com.oop.demo05;public class A extends B {@Override // 注解：有功能的注释！public void test() {System.out.println("A=>test()");}
}
B类：
package com.oop.demo05;// 重写都是方法的重写与属性无关
public class B {public void test(){System.out.println("B=>test()");}
}
执行后的结果就是：
