13.oop面向对象
1.构造器
package oop.demo_2;
public class Person {
String name;
int age;
//无参构造器
//1.实例化初始化
//2.使用new关键词，本质是在调用构造器
public Person() {
this.name = "wangs";
}
//有参构造； 如果定义了有参构造，那么必须定义无参构造
//重载
public Person(String name){
this.name = name;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
package oop.demo_2;
public class demo02 {
public static void main(String[] args) {
//new实例化一个对象
Person person = new Person("w",22);
//如果有参，那么调用有参构造器的对象，
//如果无参，那么调用无参构造器的对象。
System.out.println(person.age);
}
}
- 构造器:
- 1.和类名相同
- 2.没有返回值
- 作用:
- 1.本质在调用构造方法
- 2.初始化对象的值
- 注意点:
- 1.定义有参构造之后，如果想使用无参构造，显示定义一个无参的构造。
- this. 当前类 = 构造器相关的东西
2.私有、获取、赋值
private、get、set
package oop.demo_3;
public class Student {
//private属性私有
//创建属性
private String name;
private int age;
private int id;
private String sex;
//提供一些可以操作这个属性的方法
//提供一些public使用的方法 get、set
//使用get获得这个数据
public String getNanme(){//获取姓名
return name;
}
public int getAge() {//获取年龄
return age;
}
public int getId() {//获取ID
return id;
}
public String getSex() {//获取性别
return sex;
}
//使用set给这个数据赋值
//给姓名赋值 并打印
public void setName(String name) {
this.name = name; //将上面的 数据传过来
System.out.println(name);
}
//给年龄赋值 并打印
public void setAge(int age) {
if (age < 100 && age > 0){
this.age = age;
System.out.println(age);
}
else {
System.out.println("输入错误");
}
}
//给ID赋值 并打印
public void setId(int id) {
this.id = id;
System.out.println(id);
}
//给性别赋值 并打印
public void setSex(String sex) {
this.sex = sex;
System.out.println(sex);
}
}
package oop.demo_3;
public class demo {
public static void main(String[] args) {
//调用各个方法的 值
Student student = new Student();
student.setName("王松");
student.setAge(10);
student.setId(1);
student.setSex("男");
}
}
3.继承 extends
package oop.demo_4;
//父类 人
//所有的类都默认继承：extends object;
public class person {
//extends继承
//public 共有的
//protected 受保护的
//default 默认的
//private 私有的
//Ctrl+H 打开继承树
//父项人有1亿块钱
private int money = 10_000_0000;
public void say(){
System.out.println("说了一句话");
}
//因为是私有有，所以需要获取
public int getMoney() {
return money;
}
//获取完成后，需要赋值
public void setMoney(int money) {
this.money = money;
System.out.println(money);
}
}
package oop.demo_4;
//学生继承人
public class stduent extends person {
}
package oop.demo_4;
//老师继承人
public class teacher extends person{
}
package oop.demo_4;
public class test {
public static void main(String[] args) {
stduent stduent = new stduent();//创建一个学生对象
stduent.say(); //虽然学生类下没有方法,但是继承了人的方法，所以可以打印；
teacher teacher = new teacher();//创建一个老师对象
teacher.setMoney(1);//调用方法，继承父项的钱
System.out.println(stduent.getMoney());//继承父项的钱并打印
}
}
4.super、this
package oop.demo_5;
public class fu {//父类
public fu() {//父项无参构造器
System.out.println("父项无参执行了");
}
protected String name = "王思";//受保护的
public void print(){
System.out.println(2);
}
}
package oop.demo_5;
public class zi extends fu{//子类
//子项继承了父项所有的参数，方法
public zi() {//子项无参构造器
super();//调用父项无参 super必须放在第一位
System.out.println("子项无参执行了");
}
private String name = "王松"; //私有的
//私有的东西无法被继承
public void test(String name){
System.out.println(name);//形参
System.out.println(this.name);//王松
System.out.println(super.name);//王思
}
public void print(){
System.out.println(1);
}
public void test1(){
print();//1
this.print();//1
super.print();//2
}
}
package oop.demo_5;
import oop.demo_2.Person;
import oop.demo_3.Student;
public class Super {
public static void main(String[] args) {
fu fu = new fu();
zi zi = new zi();
zi.test("ss");
zi.test1();
}
}
//this 指：当前的
//super 指：父项
/**
* super注意点
* 1.super调用父类的构造方法，必须在构造方法的第一个
* 2.super必须只能出现在子类的方法或者构造方法中
* 3.super和this 不能同时调用构造方法
*
* VS this
* 代表的对象不同：
* this：本身调用者
* super：代表父类对象的应用
* 前提
* this：没有继承也可以使用
* super：只有在继承的条件下才可以使用
* 构造方法
* this（）：本类的构造
* super（）：父类的构造
*/
5.重写
package oop.demo_6;
public class A {
public void print(){
System.out.println("a = A");
}
}
package oop.demo_6;
public class B extends A {
//重写
@Override //注解:有功能的注解！
public void print() {
System.out.println("b = B");
}
}
package oop.demo_6;
public class Test {
public static void main(String[] args) {
//不是static静态下 调用的方法是对象的方法
//静态下 调用的是类的方法。
B b = new B();
b.print();
A a = new B();//调用父类的方法
a.print();
}
}
/**
* 重写：需要有继承关系，子类重写父类的方法；
* 1.方法名必须相同
* 2.参数列表列表必须相同
* 3.修饰符：范围可以扩大但不能缩小： public>protected>default>private
* 4.抛出的异常：范围，可以被缩小，但是不能扩大： ClassNoteFoundException > Exception（大）
*
* 重写，子类的方法和父类必须要一致，方法体不同
*
* 为什么需要重写：
* 1.父类的功能，子类不一定需要，或者不一定满足！
* 快捷键：Alt + Insert > overrode
*/
6.多态
package oop.demo_7;
public class father {
public void speak(){
System.out.println("爸爸");
}
}
package oop.demo_7;
public class boy extends father {
@Override//方法重写
public void speak() {
System.out.println("儿子");
}
public void eat(){
System.out.println("馒头");
}
}
package oop.demo_7;
public class test {
public static void main(String[] args) {
boy b1 = new boy();
father f1 = new boy();
Object o1 = new boy();
//父类不能直接调用子类的方法
((boy)f1).eat(); //强制转换
b1.eat();
//子类可以直接调用父类的方法
//子项重写后，直接重写掉父项方法
b1.speak();//调用儿子方法
f1.speak();//调用儿子方法
}
}
/**
* 多态的注意事项:
* 1.多态是方法的多态，属性没有多态
* 2.父类和子类，有联系 类型转换异常！ClassCastException
* 3.存在条件，继承关系，方法需要重写，父类引用指向子类对象！ father f = new boy();
*
* 1.static方法 属于类不属于实例；
* 2.final常量
* 3.private 私有
*
*
*/
7.instanceof关键词和类型转换
package oop.demo_8;
public class father {
}
package oop.demo_8;
public class son extends father{
public void go(){
System.out.println("go");
}
}
package oop.demo_8;
public class boy extends father{
public void run(){
System.out.println("run");
}
}
ackage oop.demo_8;
public class test {
public static void main(String[] args) {
//类型转换
// father father = new son();
// ((son)father).go(); 强制转换
//子类转换成父类 可能丢失精度（丢失一些方法）
son son = new son();//newyigeduix
father father = son; //父类转换成子类类型
father father1 = new boy();//new一个对象
boy boy = new boy();//new一个对象
boy.run();//结果run
((boy)father1).run();//强制转换 父类转换成子类类型
}
}
/**
*1.父类引用指向子类的对象
* 2.把子类转换为父类，向上转型
* 3.把弗雷转换成子类，向下转型，强制转换
* 4.方便方法调用，较少重复的代码
*
* 封装、继承、多态！ 抽象类 接口！
*/
