一，引言
面向对象的三大特征：封装，继承，多态
二，封装
2.1封装的必要性
在对象外部，给对象赋值的时候存在非法数据的录用
就目前的技术，无法对属性进行赋值规范控制
2.2什么是封装
概念：尽可能隐藏对象内部的细节，控制对象的修改及访问权限
访问修饰符：private（可将属性修饰为私有化，仅本类可见）
2.3公共访问方法
添加修饰属性私有化会导致无法在本类以外访问
以公共访问的方法形式，完成取值以及赋值的操作
问题：可以访问，还是没有解决非法数据的录入
命名规范：
赋值：xxx void set(XXX) 使用方法的参数实现赋值
取值：xxx 返回值类型 get() 使用方法的返回值实现取值
2.4过滤有效数据
在公共的访问方法内部，添加逻辑判断，进而完成过滤非法的数据，以保存数据的安全性
案例： 建立一个Product 商品类 有商品id 商品name 商品价格 商品库存 价格和库存不能直接被访问
public class Product {
int id;
String name;
private double price;
//库存
private int num;
//提供对外的公共方法
public void setPrice(double price){
if (price<0){
this.price=0;
}else {
this.price=price;
}
}
public void setNum(int num){
if (num<0){
this.num=0;
}else {
this.num=num;
}
}
//取值的方式
public double getPrice(){
//this在当前情况下可以省略 也可以不省略
return this.price;
}
public int getNum() {
return num;
}
}
---------------------------------------------------------------------------------------------
public class ProductTest {
public static void main(String[] args) {
Product product = new Product();
product.id=1001;
product.name="小米手机";
// product.price=1000; 私有化了不可在除本类以外访问
// product.num=100;
product.setPrice(-1000);
System.out.println(product.name+"的价格为："+product.getPrice());
product.setNum(-100);
System.out.println(product.name+"的库存为："+product.getNum());
}
}2.5JavaBean设计
①类：
实体类 JavaBean
②JavaBean分为两种：
1，数据承载Bean 2，业务逻辑Bean
③数据承载的Bean
1，私有化属性
2，提供对外的公共的set,get方法
3，提供有参无参构造方法
public class User {
//私有化属性
private String userName;
private String userPassword;//提供公共访问的方法
public String getUserName(){
return userName;
}
public void setUserName(String userName){
this.userName=userName;
}public String getUserPassword(){
return userPassword;
}
public void setUserPassword(String userPassword){
this.userPassword=userPassword;
}//无参构造
public User(){
}
//全参构造
public User(String userName,String userPassword){
super();
this.userName=userName;
this.userPassword=userPassword;
}三，继承
3.1程序当中的继承
-类与类之间一种赠与和获得
-两个类之间，必须满足is，a的关系
3.2父类的选择
-在现实生活当中，很多类别都是存在 is a的关系
-狗是一种动物—— 狗是一种生物—— 狗是一种物质
-很多都可以作为狗的父类，还是需要最适合狗的父类 就是 动物
3.3父类的抽象
——实战：可以根据程序需要使用到的多个具体类，进行一个共同点抽取，从而就定义了父类
——在一组相同或类似的类中，抽取共性的特征（属性）和行为（方法），定义在父类当中，实现了重用。
//父类
public class Animal {
//公共属性
String name;
int age;
String type;
//公共方法
public void sleep(){
System.out.println("睡觉....");
}
public void eat(){
System.out.println("吃饭....");
}
}//子类
public class Dog extends Animal{
//独有属性
String color;
//独有的方法
public void lookHome(){
System.out.println("会看家");
}
public void swimm(){
System.out.println("会游泳");
}
}
----------------------------------------------
//子类
public class Cat extends Animal {
//独有属性
String color;
//独有的方法
public void tuMaoBall(){
System.out.println("吐毛球");
}
}//测试
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
//使用父类继承的属性
dog.name="旺财";
dog.age=12;
dog.type="哈士奇";
//使用子类中独有的属性
dog.color="黑白";
System.out.println("姓名为："+dog.name+"年纪为："+dog.age+"品种为："+dog.type+"毛色："+dog.color);
// //使用父类继承的方法
// dog.eat();
// dog.sleep();
// //使用子类中独有的方法
// dog.swimm();
// dog.lookHome();
Cat cat = new Cat();
cat.name="喵喵";
cat.color="橘色";
System.out.println(cat.name+cat.color);
System.out.println("----------------------------");
cat.eat();
cat.tuMaoBall();
}
创建一个商品类 包含的子类 不限 子类当中有一些共同不写 通过继承来实现 子类中价格独有属性 不可以被公开访问 只能通过公共的方法访问 商品的库存不可以被修改 只能被查看
}3.4， 继承
①继承的概念：类与类之间的属性方法的赠与和获得
②继承的作用：减少代码的冗余，提高的代码的复用
③继承的语法：子类 extends父类
3.5，继承的特点
1，子类继承父类可以继承父类中的属性及方法
2，子类也可以拥有自己独立的属性及方法
3，单继承，即在Java当中和一个子类只能继承一个父类，但是一个父类可以拥有多个子类
4，多重继承，即一个父类还可以继承另一个类，java中最大的父类Object（如果一个没有显示的写出Extends父类 默认继承Object类；）
3.6，不可继承
①，构造方法不能被继承
②，私有属性不可以被继承
③，父类当中使用的默认修饰符的属性和方法在不同包的子类当中不能被继承
四，访问修饰符
（public 公共的）
（private 私有的）
（default缺省的，默认的，友好的（可以不写））
（proteted 受保护的）
public class Person {
private int a;
int b;//默认的
protected int c;
public int d;
//本类当中
public void show(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
aa();
bb();
cc();
dd();
}
private void aa(){
System.out.println("私有访问修饰符 修饰的方法");
}
void bb(){
System.out.println("默认访问修饰符 修饰的方法");
}
protected void cc(){
System.out.println("受保护的访问修饰符 修饰的方法");
}
public void dd(){
System.out.println("公共访问修饰符 修饰的方法");
}
}
--------------------------------同包不同类----------------------------------------------
public class Test {
public static void main(String[] args) {
Person person = new Person();
// person.a=100; 出了本类无法被使用
person.b=100;
person.c=100;
person.d=100;
}
}
-------------------------------------------不同包不同类-----------------------------------------
public class hh {
public static void main(String[] args) {
Person p = new Person();
// p.a=100;
// p.b=100;
// p.c=10;
p.d=100;
p.dd();
}
}五，方法的重写
①子类中有父类相同名字的方法称之为方法重写
重写的特点
相同的签名：方法名相同，参数也相同，返回值，访问修饰符更宽泛
重写的作用：
因为父类中的方法无法满足子类的一些需求，就要重写父类的方法
@Override建议在重写的方法上书写，否则会报错
注意：不能被继承的方法，就不能被重写
public class Father {
public void study(int hour){
System.out.println("学习："+hour+"个小时");
}
}
---------------------------------------------------------
public class Son extends Father {
//重写父类中的方法
@Override
public void study(int hour) {
System.out.println("儿子学习了"+hour+"个小时");
}
}
------------------------------------------------------------
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.study(8);
Father father = new Father();
father.study(8);
}
}六，Super关键字
6.1super关键字
含义：直接父类的对象
作用：可以调用父类的属性 方法 构造方法
调用父类属性和方法的时候：
① 当子类与父类有相同名字的方法的时候，this属性this.方法名（） 调用子类的属性和方法
②当子类与父类有相同名字的方法的时候，super.属性 super.方法名 调用父类中的属方法
③如果没有发生重名方法属性的情况下，那么this和super都表示调用父类的方法（子类是继承过来的）
调用父类的构造方法的时候：
注意：创建子类对象前，必须创建父类对象
1，super() 调用的父类的无参构造，是完全可以省略，都会执行（建议保留父类的无参构造方法）
②super调用父类有参构造方法的时候，要放到构造方法的第一行 super和this不能同时存在
七，多态
7.1程序中的多态
概念：
①父类引用指向子类对象，从而产生多种形态
②二者具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态
③父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。
public class Pet {
int health; //健康值
public void toHealth() {
System.out.println("宠物恢复健康");
}
}
---------------------------------------------------------
public class Dog extends Pet {
@Override
public void toHealth() {
System.out.println("狗啃骨头....");
}
public void sleep() {
System.out.println("睡觉");
}//子类所特有的父类无法调用
---------------------------------------------------------
public class Cat extends Pet {
@Override
public void toHealth() {
System.out.println("吃两条鱼....");
} public class Master {
//看病方法
//给狗看病
// public void kanbing(Dog dog) {
// if(dog.health < 80) {
// dog.toHealth();
// dog.health = 90;
// }
// System.out.println("看完病健康值为"+dog.health);
// }
//给猫看病?????
// public void kanbing(Cat cat) {
// if(cat.health < 80) {
// cat.toHealth();
// cat.health = 90;
// }
// System.out.println("看完病健康值为"+cat.health);
// }
public void kanbing(Pet pet) { //Pet pet = new Dog(); 多态
if(pet.health < 80) {
pet.toHealth();
//pet.sleep(); // pet编译期是Pet类型
pet.health = 90;
}
System.out.println("看完病健康值为"+pet.health);
}
===================================================================================
public class Test {
public static void main(String[] args) {
//创建主人类的对象
Master master = new Master();
//创建Dog类的对象
Dog dog = new Dog();
dog.health = 60;
//这里展示多态 调用主人的方法来根据不同的dog和cat对象来进行不同的看病
//主人给狗看病的方法
//master.kanbing(dog);
//创建Cat类的对象
Pet cat = new Cat();
cat.health = 50;
master.kanbing(cat);
//发生多态，父类引用无法调用子类独有的方法
//dog.sleep();
向上转型和向下转型：
//Pet pet = new Dog(); //向上转型
//Dog dog = (Dog)pet; //向下转型
//因为发生多态，则父类引用无法调用子类独有的方法，那么如果想要调用，就需要发 生向下转型。
//发生向下转型必须要先发生向上转型。ClassCastException 类转换异常
//如果想要调用子类独有的方法，那么必须要发生向下转型
Dog d = (Dog)dog; //向下转型的意义就好比如，手机新的系统有些功能没有了，夸张来说比如手机的WIFI功能没有了，那我的用旧的手机系统才能连WIFI。所以我要转回去
d.sleep();
Pet pet = new Pet();
//先判断再向下转型，避免类转换异常！！！！ 有可能对象别人传给我的 所以可能会出现转换异常 所以判断一下
if(pet instanceof Dog) {
Dog dog1 = (Dog)pet; //向下转型
dog1.sleep();
}
}
}7.2多态的特点
① 如果发生多态，那么调用的一定是子类重写的方法
②如果发生多态，那么无法调用子类自己独有方法和属性。
【编译看左边，运行看右边】( )
7.3多态的产生条件
①必须要有继承关系
②方法重写（不重写也行只是意义不大）
③必须要有父类引用指向子类的对象
7.4向上转型和向下转型
如果发生多态要调用子类自己独有的方法和属性，那么需要发生向下转型
但是发生向下转型之前必须要发生向上转型
//java
Pet pet = new Dog(); //向上转型
Dog d = (Dog)pet; //向下转型7.5instanceOf关键字
①语法：对象名 instanceof 类型
②作用：判断该对象是否属于该类型转换。属于返回true，否则返回false
③应用场景：在向下转型之前，最好先做一个判断。以免发生类型转化异常的错误
//TuXing y = new TuXing();//没有向上转型
TuXing y = new Yuan(10);//向上转型
if(y instanceof Yuan) {
Yuan y1 = (Yuan)y;//向下转型
y1.show();
}7.6多态的应用场景
①将参数改为父类类型，使用更加的宽泛和灵活
②将返回值类型改为父类类型，更将灵活
1618
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
