本文详细介绍了Java的面向对象特性，包括封装的概念和作用，如通过访问控制符隐藏类的数据；继承的原理，强调单继承和代码重用；super关键字的使用场景，如在子类构造方法中调用父类构造；以及覆盖（Override）的条件和目的；最后探讨了final关键字在类、方法和变量上的应用，并简单提及了多态的含义和重要性。
（一）、面向对象
（1）、封装
封装是把对象的所有组成部分组合在一起，封装使用访问控制符将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。
作用
适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。
①、软件包机制
*package : 设置的是编译之后的class文件的保存目录,和源文件没有关系
* 如果没有设置package语句,则class文件和java文件在同目录
*
* 软件包机制 :
* 1 为了解决命名冲突问题
* 2 package语句只能出现在java源文件的第一行
* 3 通常采用公司域名倒叙的方式
* 域名倒叙.项目名.模块名
* com.tledu.oa.system
* com.tledu.oa.model
* com.tledu.oa.controller
* 4 完整的类名是 带有包名的
* 带有包名的类
* 编译
* javac -d 生成路径 源文件
* javac -d ./ -encoding utf-8 A.java
* 运行
* java com.teldu.zrz.A
public class Package_01 {
public static void main(String[] args) {
User user = new User();
Day15.Note._05_package.com.A a = new Day15.Note._05_package.com.A();
}
}// 引入当前类中需要的其他类
// 只能在package语句之下,class语句之上
import _05_package.com.A;
// 包名.* 是引入当前包下所有类
import java.util.*;
// java.lang.* 下的类 是核心类,不需要导入
public class Package_02 {
public static void main(String[] args) {
String s = "";
Day15.Note._05_package.com.A a = new Day15.Note._05_package.com.A();
A a1 = new A();
Date d = new Date();
Arrays.asList(null);
}
}
//静态导入,在访问这个类的静态属性的时候,可以直接写名字,不需要加类名前缀
import static Day15.Note._05_package.User.a;
import static Day15.Note._05_package.User.b;
//注意 : 编码的时候,按空格和回车 会自动导包,特别注意,别导错
import java.util.Date;
public class Package_03 {
public static void main(String[] args) {
System.out.println(User.a);
System.out.println(User.b);
System.out.println(a);
System.out.println(b);
Date date = new Date();
}
}
②、权限控制
package Day15.Note._06_PPP.com;
public class B {
private static int a;
public static int b;
// default 修饰
static int c;
protected static int d;
}
package Day15.Note._06_PPP;
public class A {
private static int a;
public static int b;
// default 修饰
static int c;
protected static int d;
}
package Day15.Note._06_PPP;
import Day15.Note._06_PPP.com.B;
public class PPP_01 {
public static void main(String[] args) {
// 同包=======
// System.out.println(A.a);
System.out.println(A.b);
// default 同包
System.out.println(A.c);
// protected 同包 或者继承的子类
System.out.println(A.d);
System.out.println("---------------");
// 不同包=======
// System.out.println(B.a);
System.out.println(B.b);
// System.out.println(B.c);
// 必须要继承 才能访问
// System.out.println(B.d);
}
}（2）、继承
①、概述
从已有类中派生出新的类,新的类能有用已有类的属性和行为,并且还可以扩展新的属性和行为
目的 : 代码重用
1 java中只支持单继承,一个类只能有一个父类,但是一个类可以拥有多个子类
2 private修饰的属性,不能继承
3 使用extends关键字表示
class 子类名 extends 父类名{}
4 如果一个类没有显示继承另一个类,则该类默认继承 Object (java.lang.Object)
Object是java提供的根类(祖宗)
任何类都直接或者间接继承 Object
public class SupClass {
public void m1() {
System.out.println("父类的m1方法");
}
private int a = 2;
}public class SubClass extends SupClass {
public void m2() {
System.out.println("子类的m2方法");
}
}
public class Extends_01 {
public static void main(String[] args) {
SubClass sub = new SubClass();
sub.m1();
sub.m2();
// 私有化不能被继承
// System.out.println(sub.a);
}
}（3）、Super
①、概述
Super保存了父类型特征
②、能做什么
* super : 保存了父类型特征,可以理解为是父类对象
* 1 区分子类和父类同名的变量和方法
* 2 super(...) 只能用在子类构造方法第一行,用来调用父类构造方法
* this(...) 也是必须在构造方法第一行,所以 this()和super() 不能同时出现
* 如果构造方法中没有this() 也没有 super() 则 构造方法第一行默认有super() 调用父类无参构造
public class Sup {
public Sup() {
System.out.println("父类构造方法");
}
public Sup(int i) {
System.out.println("父类构造方法 : " + i);
}
int a = 10;
public void m1() {
System.out.println("父类的m1");
}
}public class Sub extends Sup {
public Sub() {
// 如果没有this(...)和super(...) 则默认有super() 调用父类无参构造
super(2);
System.out.println("子类构造方法");
}
int a = 20;
@Override
public void m1() {
System.out.println("子类的m1");
}
public void print() {
System.out.println(a);
System.out.println(super.a);
m1();
super.m1();
}
}
public class Super_01 {
public static void main(String[] args) {
Sub sub = new Sub();
sub.print();
}
}③、构造方法私有化
public class Super_03 {
public static void main(String[] args) {
A a = new A();
// B b = new B();
}
}
class A extends B {
A() {
// 私有化构造方法之后,该类不能被继承,因为子类构造方法中需要用到super() 去调用父类构造
super();
}
}
class B {
// private B(){
B() {
}
}（4）、Override
①、概述
覆写,重写,覆盖
继承了父类的方法,并 对其方法进行重写
* 什么时候需要重写?
* 当父类方法功能无法满足子类需求的时候,需要对父类方法,进行重写
*
* 重写条件 :
* 1 有继承关系的体系中
* 2 方法名相同,参数列表相同,返回值相同
* 3 不能比原方法拥有更低的访问权限(大于等于的关系)
* 4 不能比原方法拥有更宽泛的异常
* 5 覆写,特指成员方法,和静态变量,静态方法,成员变量无关
*
* Override和Overload区别
* 1 分别说出是什么
* 2 分别说出是干什么的
public class Override_01 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.move();
cat.m1();
Animal a = new Cat();
a.move();
a.m1();
}
}
class Animal {
public void move() {
System.out.println("动物在移动");
}
public static void m1() {
System.out.println("父类静态方法");
}
}
class Cat extends Animal {
// Override注解 是编译时注解,运行时就没有了,功能是在编译时检查,该方法是否是覆写的方法,防止写错
@Override
public void move() {
System.out.println("猫走猫步");
}
public static void m1() {
System.out.println("子类静态方法");
}
（5）、Final
①、概述
* final : 修饰符,表示最终的
*
* final修饰的类,不能被继承
* final修饰的成员方法, 不能被覆写
* fianl修饰的变量,没有默认值,并且不能二次赋值,必须显式赋值
*
* 常量 : 一般使用 public static final修饰 psf,整个程序生命周期 值不能被更改
* 常量建议命名全部大写
//final修饰的引用类型
public class Final_02 {
public static void main(String[] args) {
final User user = new User("admin");
// 可以更改,因为user使用final,并不是username,所以和堆内存对象没有关系
// 只是user变量的值不能更改而已
user.username = "root";
// 报错,因为final修饰
// user = null;
System.out.println(user.username);
}
}
class User {
String username;
public User(String username) {
this.username = username;
}
}（6）、多态
①、概述
* 多态 : 父类引用 指向子类对象
* 父类引用 : 使用父类声明的引用类型变量
* 指向 : 通过内存地址 可以找到谁
* 使用父类类型 声明的变量 保存子类对象的引用
* 父类 变量 = new 子类();
*
* java中提供了两种多态形式
* 1 编译时多态
* 编译时多态是静态的,主要是指方法重载,他是根据不同的参数列表来区分不同的方法,
* 编译之后就会变成不同的方法,在运行时,就谈不上多态了,只是不同的两个方法而已
* 2 运行时多态
* 运行时多态是动态的,主要是指动态绑定来实现,指子类实现父类的方法
②、相关知识
* 软件设计六大原则 :
* 单一职责原则 : 功能职责单一,只拥抱一种变化
* 里氏替换原则 : 所有能使用父类的地方,都可以使用子类
* 依赖倒置原则 : 细节依赖抽象
* 接口隔离原则 : 最小接口,否则需要实现很多不需要的方法
* 迪米特原则 : 最少朋友原则,低耦合,高内聚
* 开闭原则 : 对修改关闭,对扩展开放
扫一扫
578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
