Java之三大特性

1.封装

即是为了保护属性，对外只暴露想暴露的方法，实现保护数据的目的。低耦合 高内聚
一般表现为：spring（java框架体系）中bean属性的get/set方法（IDEA快捷键Alt+Insert）

package com.oop.demo02;
// 封装 保护属性 对外只暴露想暴露的方法
// 低耦合 高内聚
// 保护数据
public class Student {
private
String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
// 封装
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;
}
}

package com.oop.demo02;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.setName("大鹏");
student.setAge(6);
System.out.println(student.getName()+"今年"+student.getAge()+"岁"); // 大鹏今年6岁
}
}

2.继承

即子类继承父类 ，表示类与类之间的关系 。 若有final修饰则无法被继承
关键词：extends

子类：派生类 父类：基类
子类继承父类 拥有父类的所有方法以及属性 private除外
Java只能是单继承 即 一个爸爸多个儿子

重点：super 只能出现在子类中。相当于父类中this，可以获取父类的属性或者方法

Java中 所有的类都间接或直接继承Object类

Person 类与Student类展示super用法,A类与B类展示父子类重写，Application类为启动类

package com.oop.demo03;
// 继承 子类继承父类
类与类之间的关系
关键词：extends
// 子类：派生类
父类：基类
// 子类继承父类 拥有父类的所有方法以及属性
private除外
// Java只能是单继承
即 一个爸爸多个儿子
// 重点：super 只能出现在子类中。相当于父类中this，可以获取父类的属性或者方法
// Java中 所有的类都间接或直接继承Object类
public class Person {
public Person(){
System.out.println("父类无参构造");
}
public int money = 10000;
public void method1(){
System.out.println("父类的方法");
}
}

package com.oop.demo03;
public class Student extends Person{
public Student(){
// 子类调用父类无参构造 只能写第一层
super();// 父类无参构造
System.out.println("子类无参构造"); // 子类无参构造
}
public void method1(){
// 子类使用super调用父类的属性
System.out.println("子类使用super调用父类的属性"+ super.money); // 子类使用super调用父类的属性10000
// 子类使用super调用父类的方法
super.method1(); // 父类的方法
}
}

实现在Appcation类中

package com.oop.demo03;
public class A {
public static void test(){
System.out.println("打印A");
}
public
void test1(){
System.out.println("打印A");
}
}

package com.oop.demo03;
public class B extends A{
public static void test(){
System.out.println("打印B");
}
public
void test1(){
System.out.println("打印B");
}
}

package com.oop.demo03;
public class Application {
public static void main(String[] args) {
method3();
Application application = new Application();
application.method2();
}
// 继承的实现方法
private void method1(){
Student student = new Student();
// 实例化对象调用父类的属性
System.out.println("实例化对象调用父类的属性"+student.money); // 实例化对象调用父类的属性10000
// 实例化对象调用子类的方法
student.method1();
// 父类无参构造
// 子类无参构造
// 实例化对象调用父类的属性10000
// 子类使用super调用父类的属性10000
// 父类的方法
}
// 重写
// 子类重写父类
// 方法名称相同
参数列表相同 修饰符范围可扩大
异常范围被缩小
// 非静态方法与后面有关
private
void method2(){
A a = new A(); // 打印A
a.test1();
B b = new B(); // 打印B
b.test1();
}
// 静态方法 至于左侧有关
private static
void method3(){
A a1 = new B(); // 打印A
a1.test();
B b1 = new B(); // 打印B
b1.test();
}
}

3.多态

两种定义：
a.同一方法可以根据发送对象的不同而采用多种不同的行为方式
b.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多====》类名 别名 = new 类名，实例化左边为引用类型 右边为实际类型

注意：创建实例时，应为父类的引用指向子类，即左边 引用类型比右边 实际类型大

存在条件 :继承关系 子类重写父类方法 父类引用指向子类对象 只有方法多态

以第二种定义为例：

package com.oop.demo04;
public class A {
public void eat(){
System.out.println("父亲吃");
}
}

package com.oop.demo04;
public class B extends
A {
public void eat(){
System.out.println("儿子吃");
}
}

package com.oop.demo04;
// 多态
// 同一方法可以根据发送对象的不同而采用多种不同的行为方式
// 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多====》类名 别名 = new 类名，实例化左边为引用类型 右边为实际类型
// 存在条件
继承关系
子类重写父类方法
父类引用指向子类对象 只有方法多态
public class Application {
public static void main(String[] args) {
// 多态开始 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
B b = new B();
A a = new B();
Object o = new B();
a.eat(); // 儿子吃
b.eat(); // 儿子吃
//
o.eat(); 无方法
}
}

总目录，请点击此处，Java学习

最后

以上就是无辜小蘑菇为你收集整理的Java之三大特性Java之三大特性1.封装2.继承3.多态的全部内容，希望文章能够帮你解决Java之三大特性Java之三大特性1.封装2.继承3.多态所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。