封装:
1.封装介绍:
封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部;程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。
2.好处:
1)隐藏实现细节:方法(连接数据库)<--调用(传入参数…)
2)可以对数据进行验证,保证安全合理
3.实现步骤:
1)将属性进行私有化private 【不能直接修改属性】
2)提供一个公共的(public)set方法,用于对属性判断并赋值
public void setXxx(类型参数名){}
3)提供一个公共的(public)get方法,用于获取属性的值public数据类型
getXxx(){//权限判断,Xxx某个属性,return xX}
4.细节:
(1)封装基本需要定义属性,构造方法,get和set方法。
(2)在构造方法中,除了使用this关键字引用当前对象的实例变量,还可以使用定义的set方法。
(3)在测试类中,创建对象时用定义的set方法或构造方法来设置对象的信息。
代码示例:
package Fengzhuang;
/**
* @Author: 911
* @Description:
* 不能随便查看人的年龄,工资等隐私,并对设置的年龄进行合理的验证。
* 年龄合理就设置,否则给默认 年龄, 必须在 1-120,
* 年龄, 工资不能直接查看 , name 的长度在 2-6 字符 之间
* @Date Created in 2024-01-26 15:09
* @Modified By:
*/
public class Anli01 {
public static void main(String[] args) {
Person person = new Person();
person.setName("jack");
person.setAge(300);
person.setSalary(30000);
System.out.println(person.info());
System.out.println(person.getSalary());
//如果我们自己使用构造方法指定属性
Person smith = new Person("smith", 80, 50000);
System.out.println("====smith 的信息======");
System.out.println(smith.info());
}
}
//只有 默认和 public 可以修饰类
class Person {
public String name;
private int age;
private double salary;
public String getName() {
return name;
}
public void setName(String name) {
if (name.length() >= 2 && name.length() <= 6) {
this.name = name;
} else {
System.out.println("名字的长度不对,需要(2-6)个字符,默认名字");
this.name = "无名人";
}
}
public int getAge() {
return age;
}
public void setAge(int age) {
//年龄, 必须在 1-120
if (age >= 1 && age <= 120) {//如果是合理范围
this.age = age;
} else {
System.out.println("你设置年龄不对,需要在 (1-120), 给默认年龄 18 ");
this.age = 18;//给一个默认年龄
}
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String info() {
return "信息为 name=" + name + " age=" + age + " 薪水=" + salary;
}
public Person() {
}
public Person(String name, int age, double salary) {
// this.name = name;
// this.age = age;
// this.salary = salary;
//我们可以将 set 方法写在构造器中,这样仍然可以验证
setName(name);
setAge(age);
setSalary(salary);
}
}
继承:
1.基本介绍:
![](https://i-blog.csdnimg.cn/blog_migrate/3d1cc18f79d31f8561ac53654f9342e4.jpeg)
2.基本语法:
class 子类 extends 父类{}
1)子类就会自动拥有父类定义的属性和方法
2)父类又叫超类,基类。
3)子类又叫派生类。
3.好处:
4.细节:
5.继承的本质:
在编写代码时,要注意按照查找关系来返回信息。
6.两个小案例:
案例一:
package extend_.exercise; /** * @Author: Sober.911 * @Description: * @Date Created in 2024-01-28 16:56 * @Modified By: */ public class exercise01 { public static void main(String[] args) { B b = new B(); } } class A{ A(){ System.out.println("a"); } A(String name){ System.out.println("a name"); } } class B extends A{ B(){ this("abc"); System.out.println("b"); } B(String name){ //super();默认调用父类的无参构造器 System.out.println("b name"); } }
在Main中, B b=new B();会输出什么?
解释:首先调用B的无参构造方法,执行到this("abc");时调用B自身的带字符串的构造方法。在此构造方法中默认调用其父类A的无参构造方法,之后执行System.out.println("b")。
因此输出结果为a, b name, b
案例二:
public class ExtendsExercise02 {public static void main(String[] args) {C c = new C();}}class A {//A 类public A() {System.out.println("我是 A 类 ");}}class B extends A { //B 类 , 继承 A 类public B() {System.out.println("我是 B 类的无参构造 ");}public B(String name) {System.out.println(name + "我是 B 类的有参构造 ");}}class C extends B {//C 类,继承 B 类public C() {this("hello");System.out.println("我是 c 类的无参构造 ");}public C(String name) {super("hahah");System.out.println("我是 c 类的有参构造 ");}}
在Main中, C c = new C();会输出什么?
结果:
我是A类,hahah我是B类的有参构造,我是C类的有参构造,我是C类的无参构造
this关键字:
注意事项和使用细节:
super关键字:
1.基本介绍:
super 代表父类的引用,用于访问父类的属性、方法、构造器
2.基本语法:
1.访问父类的属性,但不能访问父类的private属性 super.属性名;
2.访问父类的方法,不能访问父类的private方法 super.方法名(参数列表);
3.访问父类的构造方法: super(参数列表);只能放在构造器的第一句,只能出现一句!
4.super 的访问不限于直接父类。
super和this的比较:
方法重写/覆盖(override):
1.基本介绍:
简单的说:方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法
2.注意事项和使用细节:
(1)子类的方法的形参列表,方法名称,要和父类方法的形参列表,方法名称完全一样。
(2)子类方法的返回类型和父类方法返回类型一样,或者是父类返回类型的子类。比如父类返回类型是Object,子类方法返回类型是String
(3).子类方法不能缩小父类方法的访问权限 public>protected >默认>private
重写与重载的比较:
多态:
1.基本介绍:
重写与重载体现多态
2.对象的多态 (核心,困难,重点)
(1)一个对象的编译类型和运行类型可以不一致
(2)编译类型在定义对象时,就确定了,不能改变
(3)运行类型是可以变化的.
(4)编译类型看定义时=号的左边,运行类型看=号的右边
3.多态注意事项和细节讨论
上转型:
1)本质:父类的引用指向了子类的对象
2)语法:父类类型 引用名=new子类类型0;
3)特点:编译类型看左边,运行类型看右边。可以调用父类中的所有成员(需遵守访问权限),不能调用子类中特有成员;最终运行效果看子类的具体实现!
下转型:
1)语法:子类类型 引用名= (子类类型)交类引用
2)只能强转父类的引用,不能强转父类的对象
3)要求父类的引用必须指向的是当前目标类型的对象
4)当向下转型后,可以调用子类类型中所有的成员
package Poly;
/**
* @Author: 911
* @Description:
* @Date Created in 2024-01-29 15:57
* @Modified By:
*/
public class Animal {
String name = "动物";
int age = 10;
public void sleep() {
System.out.println("睡");
}
public void run() {
System.out.println("跑");
}
public void eat() {
System.out.println("吃");
}
public void show() {
System.out.println("hello,你好");
}
}
package Poly;
/**
* @Author: 911
* @Description:
* @Date Created in 2024-01-29 15:58
* @Modified By:
*/
public class Cat extends Animal {
@Override
public void eat() {//方法重写
System.out.println("猫吃鱼");
}
public void catchMouse() {//Cat 特有方法
System.out.println("猫抓老鼠");
}
}
package Poly;
/**
* @Author: 911
* @Description:
* @Date Created in 2024-01-29 16:26
* @Modified By:
*/
public class Dog extends Animal{
}
package Poly;
/**
* @Author: 911
* @Description:
* @Date Created in 2024-01-29 15:59
* @Modified By:
*/
public class PolyDetail {
public static void main(String[] args) {
//向上转型: 父类的引用指向了子类的对象!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//语法:父类类型引用名 = new 子类类型();
Animal animal = new Cat();
Object obj = new Cat();//可以吗? 可以 Object 也是 Cat 的父类
//向上转型调用方法的规则如下:
//(1)可以调用父类中的所有成员(需遵守访问权限)
//(2)但是不能调用子类的特有的成员
//(3)因为在编译阶段,能调用哪些成员,是由编译类型来决定的
//animal.catchMouse();错误
//(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时,按照从子类(运行类型)开始查找方法
//,然后调用,方法调用规则一致。
animal.eat();//猫吃鱼.. animal.run();//跑
animal.show();//hello,你好
animal.sleep();//睡
//希望,可以调用 Cat 的 catchMouse 方法
//多态的向下转型
//(1)语法:子类类型 引用名 =(子类类型)父类引用;
//问一个问题? cat 的编译类型 Cat,运行类型是 Cat
Cat cat = (Cat) animal;
cat.catchMouse();//猫抓老鼠
//(2)要求父类的引用必须指向的是当前目标类型的对象!!!!!!!!!!!!!!!!!!!!!!!!!!!
//Dog dog = (Dog) animal; //可以吗?
}
}
注意:
package PolyDetail02;
/**
* @Author: 911
* @Description:属性没有重写之说!属性的值看编译类型
* @Date Created in 2024-01-29 17:41
* @Modified By:
*/
public class Detail02 {
public static void main(String[] args) {
//属性没有重写之说!属性的值看编译类型
Base base = new Sub();//向上转型
System.out.println(base.count);// ? 看编译类型 10
Sub sub = new Sub();
System.out.println(sub.count);//? 20
}
}
class Base { //父类
int count = 10;//属性
}
class Sub extends Base {//子类
int count = 20;//属性
}
instanceOf 比较操作符
package PolyDetail03;
/**
* @Author: 911
* @Description:instanceOf 比较操作符,
* 用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型
* @Date Created in 2024-01-29 17:43
* @Modified By:
*/
public class Detail03 {
public static void main(String[] args) {
BB bb = new BB();
System.out.println(bb instanceof BB);// true
System.out.println(bb instanceof AA);// true
//aa 编译类型 AA, 运行类型是 BB
//BB 是 AA 子类
AA aa = new BB();
System.out.println(aa instanceof AA);
System.out.println(aa instanceof BB);
Object obj = new Object();
System.out.println(obj instanceof AA);//false
String str = "hello";
//System.out.println(str instanceof AA);
System.out.println(str instanceof Object);//true
}
}
class AA{
}
class BB extends AA{
}