1、面向对象概念
面向对象本质：以类的方式组织代码，以对象的方式封装数据
三大特性
- 继承
- 封装
- 多态
思想和 C++中一样，以下总结把重点放在了 Java 代码的写法和 C++ 的不同之处
2、对象实例化
Java 的写法和 C++ 几乎一样，C++ 中堆内存会将返回地址交给一个指针管理，Java 中直接通过对象管理
Java 创建对象内存分析图
3、继承封装多态
封装
高内聚:类的内部数据操作细节自己完成，不允许外部干涉
低耦合:仅仅暴露少量的方法给外部使用
写法和 C++ 没啥区别，但是注意每个方法前面都要加权限
继承
对某一批类的抽象，实现更好的建模，通过关键字 extends 进行继承，这是和 C++ 不同的地方，注意 java 中只有单继承，没有多继承
public class Demo3Telecent extends Student{
}
在 Java 中，所有的类都默认直接或间接继承 Object 类
后期 Object 将会是学习的重点
super 和 this 区别
- super 调用父类的构造方法必须在构造器的第一个
- super 必须只能出现在子类方法或者构造器中
- super 和 this 不能同时调用构造方法
- this 代表本身调用者这个对象，super 代表父类对象引用
- this 在没有继承的时候也可以使用，super 只能在继承条件下才可以使用
- this 默认调用本类构造，super 默认调用父类构造
多态
多态：需要有继承关系，子类重写父类方法
- 方法名，参数列表必须相同
- 修饰符，范围可以扩大，但是不可以缩小
- 抛出的异常可以被缩小，但是不能扩大
- 多态编译，具有可扩展性
多态是方法的多态，而不是属性的多态
Java 写法和 C++ 写法稍有不同
public class Demo3Telecent extends Student{
@Override // 子类重写父类的 say 函数
public void say() {
System.out.println("学生又在说话了！");
}
}
Java 需要在子类方法的上一行加 @Override，父类方法不需要做任何变动， 而 C++ 是父类的函数的前面加 virtual ，变为一个虚函数，子类可以加 virtual ，也可以不加
instanceof 引用类型的转换
它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。可以用来判断继承中的子类的实例是否为父类的实现
public class Demo2Application {
public static void main(String[] args) {
// Object 指向 Student
Object object = new Student();
// 满足父子关系，返回 true
System.out.println(object instanceof Student);
}
}
4、static 变量
概念和 C++一样，这里就不总结了
在 java 中可以使用静态代码块，也就是匿名代码块
public class Person {
static {
// 这里做初始化的工作
}
}
当创建对象的时候，按照下面执行顺序
public class Person {
// 当创建对象的时候，按照下面执行顺序
static {
// 静态代码块，这里做初始化的工作，只执行一次
System.out.println("静态代码块");
}
{
// 匿名代码块，赋初始值
System.out.println("匿名代码块");
}
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
}
}
5、抽象类和接口
含有 abstract 修饰符的 class 即为抽象类，abstract 类不能创建实例对象，抽象类中可以实现方法的实现，也可以直接声明方法，在子类中实现，相当于 C++ 中的虚函数，可以在父类实现，也可以在子类实现，比较灵活！
public abstract class Demo5Abstract {
/**
* 抽象方法，只有抽象名字，没有方法的实现
*/
public abstract void doSomething();
}
// 不能 new 这个抽象类，只能靠自类去实现它,抽象方法也必须在子类中
C++ 写法是
virtual void doSomething() = 0;
接口定义
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为 public abstract类型，接口中的成员变量类型默认为public static final
这个相当于 C++ 中的虚基类，每一个虚基类至少有一个纯虚函数，纯虚函数必须在子类实现，父类仅仅提供声明，无法实现具体内部…
定义接口
/**
* @Title: Demo6UserService
* @Package oop
* @Description: interface 定义的关键字，接口都需要有实现类
* @author: maze
* @date 2020/10/15下午 20:24
*/
public interface Demo6UserService {
//接口中所有定义的其实都是 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
实现接口类，重写方法
/**
* @Title: Demo6UserServiceImpl
* @Package oop
* @Description: 实现接口类,重写接口中的方法
* @author: maze
* @date 2020/10/15下午 20:28
*/
public class Demo6UserServiceImpl implements Demo6UserService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
接口的作用
- 约束
- 定义一些方法，让不同的人去实现
- 接口不能直接被实例化，因为接口中没有构造方法
- implements 可以实现多个接口
- 实现接口，必须重写接口中的方法
抽象类和具体类的相同之处和区别
1、抽象类和接口都不能直接实例化，没有构造方法
2、抽象类中可以存在非抽象的方法，接口必须都为 public 且没有具体实现的抽象方法
3、抽象类中的成员变量可以被不同的修饰符修饰，可接口中的成员变量默认都是静态变量 static final
4、接口用来解决多重继承的问题，抽象类只能单继承
5、抽象类是对象的抽象，接口则是一种行为规范
6、N 中内部类
在一个类中再定义一个类
public class Out {
private int id;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
}
}
主程序调用
public class Main {
public static void main(String[] args) {
Out out = new Out();
Out.Inner inner = out.new Inner();
inner.in(); // 输出内部类的方法实现
}
}
内部类可以做啥？
(非静态)内部类可以获取外部类所有的方法和属性
类似于 C++ 中的友元类，可以访问友元类中的所有成员
另外还有局部内部类，就是在一个方法中定义一个类；还有匿名内部类，很多源码都是这样写的，比如
public class Test {
public static void main(String[] args) {
}
UserService userService = new UserService(){
@Override
public void hello() {
//你好
}
};
}
interface UserService{
void hello();
}
7、异常
你写的模块，用户输入不一定符合你的要求；程序要打开的文件不存在，或者打开的文件格式不对；读取数据的时候内存或者硬盘满了，这些都可能抛出异常
异常的作用就是让程序作出合理的处理，而不至于使程序崩溃
比如：栈溢出
public class Demo1 {
public static void main(String[] args){
new Demo1().start();
}
public void start(){
end();
}
public void end(){
start();
}
}
异常的分类
- 检查性异常：用户出错问题引起的异常，这是程序猿无法预见的，例如打开一个文件不存在，会抛出异常！
- 运行时异常：在编译期间不会出错，运行的时候导致，比如栈溢出
- 错误 Error： 脱离程序的控制，比如虚拟机异常，这个时候一般会终止线程
异常处理机制
案例1：除数为 0
public class Demo1 {
public static void main(String[] args){
int a = 1;
int b = 0;
try{
System.out.println(a/b);
}
catch (Exception e){
System.out.println("程序出现异常！");
}
finally {
System.out.println("这里一般做程序的善后工作");
}
}
}
案例2：栈溢出
public class Demo1 {
public static void main(String[] args){
// Ctrl + alt + t
try {
new Demo1().start();
} catch (Throwable e) {
System.out.println("程序崩溃异常");
e.printStackTrace();
} finally {
System.out.println("finally");
}
}
public void start(){
end();
}
public void end(){
start();
}
}
案例3：主动抛出一个异常
public class Demo1 {
public static void main(String[] args){
try {
new Demo1().test(1,0);
}
catch (ArithmeticException e){
e.printStackTrace();
}
}
// 假设这个方法处理不了异常，主动抛出
public void test(int a,int b){
// 主动抛出异常,一般用在方法
if(b == 0){
throw new ArithmeticException();
}
}
}
自定义异常
public class MyException extends Exception{
private int detail;
public MyException(int a) {
this.detail = a;
}
// 异常打印信息
@Override
public String toString() {
return "MyException{" + "detail=" + detail + '}';
}
}
测试类
public class Main {
public static void test(int a) throws MyException{
System.out.println("传递的参数为:"+a);
if(a >10){
throw new MyException(a);
}
System.out.println("ok");
}
public static void main(String[] args) {
try {
test(11);
}
catch (MyException e){
System.out.println("MyException=>"+e);
}
}
}
思考题
1、为什么C++ new 出来的需要使用指针管理，而 Java 不需要指针？
2、为什么 Java 只有单继承，没有多继承？
3、抽象类存在构造器吗？抽象类存在的意义在哪？
扫一扫
5608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
