封装:
面向对象的三大特性:封装继承和多态。
封装的意义在于保护或者防止代码(数据)被我们无意中破坏。保护成员属性,不让类以外的程序直接访问和修改。
private私有,封装原则:隐藏对象属性和实现细节,仅对外公开访问方法,并且控制访问级别。封装对象的成员属性,提供一个可供操作的方法。当私有了一个属性以后,提供一个用于设置和获取的方法。
package com.zx;
//创建一个普通的类Person,普通的成员属性和成员方法
public class Person {
String name;
int age;
void say() {
System.out.println(name + age);
}
}
package com.zx;
public class demo {
public static void main(String[] args) {
//创建Person对象
Person p1 = new Person();
//对象名.属性名直接可以赋值
p1.age = 18;
p1.name = "张三";
p1.say();//张三18
}
}
package com.zx;
//当给属性添加封装private关键字以后,外部不可以直接对象名.属性名赋值
public class Person {
private String name;
private int age;
void say() {
System.out.println(name + age);
}
}
此时代码是报错状态
封装原则:隐藏对象属性和实现细节,仅对外公开访问方法,并且控制访问级别。封装对象的成员属性,提供一个可供操作的方法。当私有了一个属性以后,提供一个用于设置和获取的方法。get(获取),set(设置)
package com.zx;
//当给属性添加封装private关键字以后,外部不可以直接对象名.属性名赋值
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
void say() {
System.out.println(name + age);
}
}
package com.zx;
public class demo {
public static void main(String[] args) {
Person p1 = new Person();
p1.setAge(18);
p1.setName("张三");
p1.say();//张三18
}
}
静态static:
通过静态修饰的属性存储到方法区中,被静态修饰的变量不需要依赖于对象进行访问,只要类被加载了,就可以通过类名访问。(非静态修饰的属性理解为对象的属性,根据图纸创建出来的一个个实例,而静态修饰的属性理解为类的属性,图纸自身已经定好的属性)。
无论一个类存在多少个对象,静态的属性和方法永远在内存中只有一份,类被加载时,静态的成员就被初始化了。
静态修饰的方法,不需要创建对象再去调用了,可以直接通过类去调用。静态的资源可被调用的时机早于非静态修饰的方法。
在访问时,静态的资源不能访问非静态,非静态可以访问静态。(非静态的资源可以使用了表示对象已经存在,对象已经存在表示类已经加载,类已经加载静态资源一定存在,所以可以去访问)。
继承:
继承允许我们编写类的时候给类进行等级层次的划分,可以把一些类变成父类,一些类变成子类。父类里边所拥有的行为和方法可以被子类所继承。
子类除了可以从父类继承以外,还可以有自己的部分。继承的有属性和方法。
使用extends关键字
package com.zx;
public class Student extends Person {
private String number;
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public void showAll() {
System.out.println(getName() + getAge() + number);
}
}
package com.zx;
public class demo {
public static void main(String[] args) {
Student s1=new Student();
s1.setAge(19);
s1.setName("李四");
s1.setNumber("1001");
s1.say();//从父类继承的say方法李四19
s1.showAll();//自己独有的showAll方法李四191001
}
}
子类实例化内存分析:
java中只有单继承,多重继承,没有多继承。
多继承(贴切生活中的概念就是一个孩子有多个爹),多重继承(a和b这两个类c都想去继承,这就可以b继承a,c再继承b)。
当我们创建子类对象时,首先会先创建它的父类对象,把父类对象创建完毕之后才会创建自己,并且父类对象会作为自己这个对象里的super(指向父类)部分存在。(所谓的继承只是子类拥有父类的一个地址而已)。
权限修饰符,在子父里边能访问的只有public和protected,父的方法和属性只有这两种修饰的子类才可以操作。
抽象类:
要求:一个.Java文件只编写一个类,且这个类通过public修饰
之前编写的类,比如说描述一个人,这个人的一些细节,某些属性,某些行为,描述的很具体,这叫做实现类。
抽象的类指的是类所描述的行为和方法是模糊的。抽象类本身是不能进行实例化操作的,不能直接通过new关键字来完成。如果想对抽象的部分进行实例化创建对象,必须把抽象的部分明确,明确的方式是编写一个子类把父类中不能确定的部分明确了,这种操作称为实现实现父类的抽象方法。抽象类必须被子类所继承。
package com.zx;
//抽象类
public abstract class Person {
//抽象方法
public abstract void say();
//非抽象方法
public void show(){
System.out.println("非抽象方法");
}
}
package com.zx;
public class Student extends Person {
//如果想对抽象的部分进行实例化创建对象,必须把抽象的部分明确,
// 明确的方式是编写一个子类把父类中不能确定的部分明确了,
// 这种操作称为实现实现父类的抽象方法。抽象类必须被子类所继承。
@Override
public void say() {
System.out.println("我是Student类,实现Person类的say方法");
}
}
package com.zx;
public class demo {
public static void main(String[] args) {
Student s1=new Student();
s1.say();//我是Student类,实现Person类的say方法
s1.show();//非抽象方法
}
}
抽象类常见问题:
抽象类是不能直接创建对象的。
抽象类中抽象和非抽象的方法都可以有。
抽象类不能使用final声明,final修饰的类是最终的类,不能拥有子类,不可以被继承,一个抽象类不能被继承就无法实现。
抽象类是否有构造方法?
能有构造方法,只是jvm限制开发者不能通过new来创建抽象类对象,但是java内部是可以自己创建的,当我们创建子类对象时,首先会先创建它的父类对象,把父类对象创建完毕之后才会创建自己,会把你已经实现的部分创建出来,因为抽象的部分子类已经实现了。
抽象类和普通类的区别:抽象类必须用public或protected修饰,如果把一个类私有了,私有的类子类无法继承。
在子类创建对象时,抽象父类也会被jvm实例化。
如果一个子类继承一个抽象类必须实现所有的抽象方法,如果有未实现的抽象方法,那么子类必须定义成abstract类。
abstract不能和以下两个关键字同用。
native修饰的方法代表该方法已经被实现。
private修饰的私有方法不能被继承的
接口:
接口的概念和抽象类很像,如果一个类里边有部分不能确定的地方,可以把类设计成抽象类,把能确定的部分先写好,不能确定的部分设计为抽象方法。
接口里边全是抽象部分,接口里边只能有抽象方法和全局常量。
因为接口里边都是抽象的部分,需要依赖于实现类。
接口的意义:1、弥补不能多继承的不足。2、提供统一的标准和规则,作为模板,所有的实现类都按照这个模板去写。
面向接口编程思想:
之前写代码都是把具体的细节部分先编写好,之前的面向对象,把细节部分都封装到对象里,之后来回调用这些对象来实现某个操作。
面向接口编程思想指的是我们一直关注的都是抽象部分,一个项目没有写的时候就通过抽象的方式把规范约束先定义出来(程序大概有哪些功能),从宏观的角度先把程序设计好,但是程序流程中没有任何可实现的代码。
接口可以多实现,一个类可以实现多个接口,接口与接口之间可以继承,并且也允许多继承。
如果一个接口要想使用必须依靠子类,如果一个接口没有子类是没有意义的。
接口和抽象类之间的区别:
抽象类必须被子类继承,接口被子类实现。
接口只能声明抽象方法,而抽象类抽象非抽象都可以。
接口里定义的变量是全局常量,抽象类可以是普通变量。
抽象类使用继承,没有办法多继承,接口使用实现,可以多实现。
抽象类中可以包含static方法,而接口不行(静态方法不能被子类重写,而接口必须被子类继承实现)。
接口不能有构造方法,抽象类有。
package com.zx;
//接口
public interface Person {
public abstract void say();
public void show();
}
package com.zx;
//接口必须使用implements关键字,而抽象类使用extends
public class Student implements Person {
@Override
public void say() {
System.out.println("我实现Person接口里的say方法");
}
@Override
public void show() {
System.out.println("我实现Person接口里的show方法");
}
}
package com.zx;
public class demo {
public static void main(String[] args) {
Student s1=new Student();
s1.say();//我实现Person接口里的say方法
s1.show();//我实现Person接口里的show方法
}
}
多态:
面向对象的三大特征:封装,继承,多态。
多态:对象的多种形态。设计的Person类(抽象类),后边有子类,一个是student。就可以称之为学生是人的一种形态。
多态可以总结一句话:父类引用指向子类对象,父类引用指的就是父类的对象名称等于(指向)子类对象。
public class demo {
public static void main(String[] args) {
Person p = null;
//Person是父类,Student是子类,Student属于Person
Student s = new Student();
p = s;//右边s这个对象是左边类型的一种形态
//相当于说一个学生是人,虽然说p是Person类型但是具体指向的内容是这种类型的另一种子形态
p.say();//我是学生
}
}
public class demo {
public static void main(String[] args) {
Student a = new Student();//创建一个学生a
Person p1 = a;//学生a是人类p1的一种形态
p1.say();//调用say方法,我是学生
Student a1 = (Student) p1;//p1已经是一个人的学生形态,再转换成学生
a1.say();//我是学生
}
}
instanceof:
如何判断传入的对象是此类型的哪一种形态(哪个子类的对象)。
public class demo {
public static void main(String[] args) {
Student s=new Student();
say(s);
}
public static void say(Person p) {
//如果能进入if则意味着p就是Student的形态
if (p instanceof Student){
Student s = (Student) p;
s.say();
}else{
System.out.println("必须传入学生形态");
}
}
}