今天我们来了解一下面向对象的三大特性:封装、继承和多态。
把属性和实现细节隐藏起来,不让外界直接访问,提供公共的方法访问方式。
A:只能修饰成员
B:被private修饰的成员只能在本类中访问,外界不可以直接访问
C:private是一个权限修饰符
使用:
1)给成员属性加private
2)提供关于这个属性的公共的set和get方法
class Demo_Person {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "张三";//调用姓名属性并赋值
//p1.age = -17; //因为age是私有的所以 不能直接调用赋值
//p1.speak(); //调用行为
p1.setAge(-17);
System.out.println(p1.getAge());
}
}
//人的类
class Person {
String name; //姓名
private int age; //年龄
public void setAge(int a) { //设置年龄
age = a;
}
public int getAge() { //获取年龄
return age;
}
public void speak() {
//这里可以直接使用age是因为是在Person类里面
System.out.println(name + "..." + age);
}
}
指的是当前对象的引用
用途:用来区分成员变量和局部变量重名
class Demo1_This {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("张三");
p1.setAge(23);
System.out.println(p1.getName() + "..." + p1.getAge());
Person p2 = new Person();
p2.setName("李四");
p2.setAge(24);
System.out.println(p2.getName() + "..." + p2.getAge());
}
}
class Person {
private String name; //姓名
private int age; //年龄
public void setAge(int age) { //设置年龄
this.age = age;
}
public int getAge() { //获取年龄
return age;
}
public void setName(String name) { //设置姓名
this.name = name;
}
public String getName() { //获取姓名
return name;
}
}
构造方法是为了创建对象而存在的,一个对象的创建肯定会执行构造方法。一般在构造方法中做初始化操作。构造方法的的特点:没有返回值,连void都不能有;方法名和类名一模一样;方法里面没有返回值(但是可以写一个单独的 return;)
构造方法可以重载(只要符合重载的条件就可以:方法名相同,参数列表不同)
代码:
class Person {
private String name;
private int age;
//构造方法
public Person() {
}
public Person(String name,int age) {
this.name = name;
this.age = age;
}
}
A:如果我们在一个类中没有给出构造方法, 系统将默认给出一个无参构造
B:如果我们给出了构造方法, 系统将不再提供无参构造(所以我们以后在定义类的时候,永远手动给出无参构造)
有参构造方法,是在创建对象的同时顺便给成员变量进行赋值 ,强调的是创建对象 而set方法 就是为了给成员变量赋值的一个方法
特点:
代码:
class Person {
String name; //姓名
static String country; //国籍
public void speak() { //说话的方法
System.out.println(name + "..." + country);
}
}
class Demo1_Static {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "苍老师";
p1.country = "日本";
Person p2 = new Person();
p2.name = "小泽老师";
p1.speak(); //打印出 苍老师...日本
p2.speak(); //打印出 小泽老师...日本
Person.country = "日本"; //静态多了一种调用方式,可以通过类名.
System.out.println(Person.country);
}
}
1:静态方法里面不能有this关键字(原因是因为静态是随着类的加载而加载,this是随着对象的创建而存在。静态比对象先存在)
2:非静态的能访问静态的;静态的不能直接访问非静态的;如果静态的非得访问非静态的内容,请创建对象使用非静态的内容。
代码体现:
class Demo {
int num1 = 10; //非静态的成员变量
static int num2 = 20; //静态的成员变量
public void print1() { //非静态的成员方法,既可以访问静态的成员也可以访问非静态的
System.out.println(num1);
System.out.println(num2);
}
public static void print2() { //静态的成员方法
//System.out.println(num1);//静态的成员方法不能访问非静态的,错误: 无法从静态上下文中引用非静态 变量 num1
Demo d = new Demo(); //如果静态的非要访问非静态的内容 请创建对象使用
System.out.println(d.num1);
System.out.println(num2);
}
}
在java中用{}括起来的称为代码块。
例子:
class Student {
static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法");
}
}
class Demo_Student {
static {
System.out.println("Demo_Student静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
执行结果:
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
继承就是子类继承父类的特征和行为。extends:是个关键字,表示子类继承父类。被继承的类叫做父类或基类或超类,继承的类叫做子类或者派生类。
耦合性:假如我只想修改父类中的方法,但是又不想修改子类中的方法,可是我只要修改了父类中的内容,子类继承父类 子类中的内容也就被一起修改了。
java只支持单继承不支持多继承,但是可以多层继承。如果想用这个体系的所有功能用最底层的类创建对象,如果想看这个体系的共性功能,看最顶层的类 。代码如下:
class Demo_Extends {
public static void main(String[] args) {
DemoC d = new DemoC();
d.show();
d.method();
d.print();
}
}
class DemoA {
public void show() {
System.out.println("DemoA");
}
}
class DemoB extends DemoA {
public void method() {
System.out.println("DemoB");
}
}
class DemoC extends DemoB {
public void print() {
System.out.println("DemoC");
}
}
多态是同一个行为具有多个不同表现形式或形态的能力。
成员变量:编译看左边,运行看左边 成员方法:编译看左边,运行看右边 静态方法:编译看左边,运行看左边(静态和类相关,算不上重写,所以,访问还是左边的) 在多态的时候,父类的引用除了子类重写的方法是调用的子类的之外, 其他的都是调用的父类自己的,如果父类没有,编译就报错。
class Demo3_SuperMan {
public static void main(String[] args) {
Person p = new SuperMan();//父类引用指向子类对象,超人提升为了人
//父类引用指向子类对象就是向上转型
System.out.println(p.name);
p.谈生意();
SuperMan sm = (SuperMan)p;//向下转型
sm.fly();//只有父类的引用强转成子类后,才能使用子类特有的功能
}
}
class Person {
String name = "John";
public void 谈生意() {
System.out.println("谈生意");
}
}
class SuperMan extends Person {
String name = "superMan";
public void 谈生意() {
System.out.println("谈几个亿的大单子");
}
public void fly() {
System.out.println("飞出去救人");
}
}
阿Q用了两天的时间把这块做了简单总结,如果有什么不懂得地方可以给阿Q留言今。想了解更多学习知识,请关注微信公众号“阿Q说”,获取更多学习资料吧!你也可以后台留言说出你的疑惑,阿Q将会在后期的文章中为你解答。每天学习一点点,每天进步一点点。