面向对象的三大特征
面向对象的三大特性
封装
package com.zzl.oop2.Demo1.Demo4;
//类 private： 私有
public class Student1 {
//名字
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 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 = 3;}
else {
this.age = age;
}
}
//学习（）
//睡觉（）
}
/*
package com.zzl.oop2.Demo1;
import com.zzl.oop2.Demo1.Demo4.Student1;
/*
封装（属性私有，get/set）
1.提高程序的安全性，保护数据
2.隐藏代码的细节
3.统一接口
4.系统可维护性增加
*/
/*//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类是抽象的，实列化
//类实例化后会返回一个自己的对象；
Student1 s1 = new Student1();
//私有不能直接调用
s1.setName("周子龙");
System.out.println(s1.getName());
s1.setAge(9999);
System.out.println(s1.getAge());
}
}
*/
属性私有，get/set
继承
person
package com.zzl.oop2.Demo1.Demo5;
//Person 学生也是人
//在Java中，所有类，都默认直接或者间接继承object
//java中的只有单继承没有多继承---》一个孩子只能有一个爸爸，一个爸爸可以有多个孩子
public class Person {
public Person(){
System.out.println("父类无参");
}
//四个优先级 public protected default private
private int money = 10_0000_0000;
protected String name = "xiaoge";
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public void say(){
System.out.println("爸爸说了一句话");
}
}
student
package com.zzl.oop2.Demo1.Demo5;
import com.sun.jmx.snmp.SnmpUnknownAccContrModelException;
import java.util.Scanner;
//学生是人
//子类继承了父类，就会拥有父类的全部方法！（public）
//ctrl+h
public class Student extends Person{
//隐藏代码：调用了父类的无参构造器
public Student(){
super();//调用父类无参构造器，必须要在子类构造器的第一行
System.out.println("子类无参");
}
private String name = "zhouzilong";
public void say(){
System.out.println("我说了一句话");
}
//私有的类无法被继承
public void test1(){
this.say();
super.say();
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
package com.zzl.oop2.Demo1;
import com.zzl.oop2.Demo1.Demo4.Student1;
import com.zzl.oop2.Demo1.Demo5.Student;
/*
封装（属性私有，get/set）
1.提高程序的安全性，保护数据
2.隐藏代码的细节
3.统一接口
4.系统可维护性增加
*/
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类是抽象的，实列化
//类实例化后会返回一个自己的对象；
Student student = new Student();
student.say();
student.test("jiangyuanli");
student.test1();
Person person = new Person();
person.getClass();
}
}
super
注意点
-
super是调用父类的构造方法，必须在构造方法的第一个
-
super只能出现在子类的方法或者构造方法中
-
super和this不能同时调用构造方法
vs this
-
代表对象不同
this：本身调用者这个对象
super： 代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件才能使用
构造方法
this（）：本类的构造
super（）： 父类的构造
重写
重写需要有继承关系，子类重写父类的方法！
-
方法名必须相同
-
参数列表必须相同
-
修饰符：范围可以扩大但不能缩小：Public》Protected》Default》Private
-
抛出异常：范围可以被缩小，但不能扩大
-
重写子类的方法必须和父类必要一致，方法体不同！
为什么需要重写
1.父类的功能，子类不一定需要，或者不一定满足！
Ait+Insert：Override
package com.zzl.oop2.Demo1;
import com.zzl.oop2.Demo1.Demo4.Student1;
import com.zzl.oop2.Demo1.Demo5.A;
import com.zzl.oop2.Demo1.Demo5.B;
import com.zzl.oop2.Demo1.Demo5.Student;
/*
封装（属性私有，get/set）
1.提高程序的安全性，保护数据
2.隐藏代码的细节
3.统一接口
4.系统可维护性增加
*/
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类是抽象的，实列化
//类实例化后会返回一个自己的对象；
//静态和非静态的方法区别很大！
//静态方法：方法的调用只和左边，定义的数有关系
//非静态：重写，子类重写父类
B b = new B();
b.aa();
//父类的引用指向了子类
A a = new B();//子类重写了父类的方法
a.aa();
}
}
=================================================
父类
package com.zzl.oop2.Demo1.Demo5;
public class A {
public void aa(){
System.out.println("aaaa");
}
}
子类
package com.zzl.oop2.Demo1.Demo5;
public class B extends A {
@Override
public void aa() {
System.out.println("bbb");
}
}
多态
package com.zzl.oop2.Demo1;
import com.zzl.oop2.Demo1.Demo4.Student1;
import com.zzl.oop2.Demo1.Demo5.A;
import com.zzl.oop2.Demo1.Demo5.B;
import com.zzl.oop2.Demo1.Demo6.Person;
import com.zzl.oop2.Demo1.Demo6.Student;
/*
封装（属性私有，get/set）
1.提高程序的安全性，保护数据
2.隐藏代码的细节
3.统一接口
4.系统可维护性增加
*/
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类是抽象的，实列化
//类实例化后会返回一个自己的对象；
//静态和非静态的方法区别很大！
//静态方法：方法的调用只和左边，定义的数有关系
//非静态：重写，子类重写父类
//一个对象的实际类型是确定的
//new Student
//new Person
//可以指向的引用类型就不确定了,父类指向子类
//子类能调用的方法都是自己的或者父类的
Student s1 = new Student();
//父类只能调用自己的
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法主要看左边的类型，与右边关系不大！
s2.run();
s1.run();
((Student) s2).eat();//强转
}
}
/*
多态的注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常 ClassCastException!
3.存在条件： 继承关系，方法需要重写，父类的引用指向子类对象 father f1 = new son
不可重写的方法
1.static方法属于类，它不属于实例
2.final 常量
3.private 方法package com.zzl.oop2.Demo1.Demo6;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("chi");
}
}
*/
父类
package com.zzl.oop2.Demo1.Demo6;
public class Person {
public void run(){
System.out.println("run");
}
}
子类
package com.zzl.oop2.Demo1.Demo6;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("chi");
}
}
Instanceof
package com.zzl.oop2.Demo1.Demo6;
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
/*
//Object>String
//Object>Person>Student
//Object>Person>Teacher
Object object = new Student();
//System.out.println(X instanceof Y); 能不能编译通过关键看X与Y这条关系线上的关系
System.out.println(object instanceof Student);
System.out.println(object instanceof Person);
System.out.println(object instanceof Object);
System.out.println(object instanceof Teacher);
System.out.println(object instanceof String);
System.out.println("==========================");
//Object>Person>Student
Person person = new Student();
System.out.println(person instanceof Student);
System.out.println(person instanceof Person);
System.out.println(person instanceof Teacher);
System.out.println(person instanceof Object);
*/
类型转换
package com.zzl.oop2.Demo1;
import com.zzl.oop2.Demo1.Demo4.Student1;
import com.zzl.oop2.Demo1.Demo5.A;
import com.zzl.oop2.Demo1.Demo5.B;
import com.zzl.oop2.Demo1.Demo5.Person;
import com.zzl.oop2.Demo1.Demo6.Student;
import com.zzl.oop2.Demo1.Demo6.Teacher;
/*
封装（属性私有，get/set）
1.提高程序的安全性，保护数据
2.隐藏代码的细节
3.统一接口
4.系统可维护性增加
*/
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类是抽象的，实列化
//类实例化后会返回一个自己的对象；
//静态和非静态的方法区别很大！
//静态方法：方法的调用只和左边，定义的数有关系
//非静态：重写，子类重写父类
//一个对象的实际类型是确定的
//new Student
//new Person
//可以指向的引用类型就不确定了,父类指向子类
//子类能调用的方法都是自己的或者父类的
//父类只能调用自己的
//对象能执行哪些方法主要看左边的类型，与右边关系不大！
//类型之间的转化：父 子
//高 低
/* Person obj = new Student();
//student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
Student student = (Student) obj;
student.go();
//简便式（(Student)obj).go();
*/
//子类转换为父类，可能丢失自己本来的一些方法
Student student = new Student();
student.go();
//Person person = student;
/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型（强制转化）
4.方便方法是调用，减少重复的代码
*/
}
}
/*
多态的注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常 ClassCastException!
3.存在条件： 继承关系，方法需要重写，父类的引用指向子类对象 father f1 = new son
不可重写的方法
1.static方法属于类，它不属于实例
2.final 常量
3.private 方法
*/
浙公网安备 33010602011771号