面向对象
面向对象编程（Object-Oriented Programming,OOP）
面向对象编程的本质是：以类的方式组织代码，以对象的方式组织（封装）数据
抽象
面向对象的三大特性：封装、继承、多态
return 结束方法，返回一个结果
方法调用
public class Demo01{
public static void main(String[] args){
Person person = new Person();
System.out.println(person.name); //null
Demo01.change(person);
System.out.println(person.name); //123
}
public static void change(Person person){
person.name = "123";
}
}
class Person{
String name;
}
认识论：先有对象后有类
对象：是具体的事物
类：是抽象的，是对对象的抽象
代码运行角度：先有类后有对象
类是对象的模板
创建于初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对
构造方法
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下2个特点：
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下2个特点：
- 必须和类的名字相同
- 必须没有返回类型也不能写void
- 一个类即使什么都不写，默认也包含一个不太参数的构造方法
- 定义了有参的构造方法后，如果想使用无参构造方法，必须显示声明
- 使用new关键字，本质是调用构造器来初始化值
- 属性：字段Field 成员变量
- 默认初始化：
- 数字 0 0.0
- char: u0000
- boolean: false
- 引用：null
类和对象小结
-
对象的引用
注意
- 静态方法 - 与类一同加载
- static 类名.方法名()
- 非静态方法
- 对象类型 对象名 = new 对象类型();
- 对象名.方法名();
- 一个类中只能有一个public class类，可以有多个class
- 静态方法 - 与类一同加载
-
对象的使用
类 抽象 动物
对象 具体 猫
public class Student{
/*
* 类中只能包含属性和方法
*/
String name;
public void study(){
System.out.println(this.name + "在学习！");
}
}
public class Demo01{
public static void main(String[] args){
//定义Student类的不同对象
Student xiaoming = new Student();
Student xiaohong = new Student();
xiaoming.name = "小明";
xiaohong.name = "小红";
System.out.println(xiaoming.name);
System.out.println(xiaohong.name);
}
}
封装
高内聚，低耦合
封装：禁止直接访问一个对象中的数据的实际表示，而是通过对应的接口来访问
属性私有，get/set private
意义：
- 提高程序的安全性
- 隐藏代码的实现细节
- 统一接口
public class Application{
public static void main(String[] args){
Demo01 student = new Demo01();
student.setName("xiaoming");
System.out.println(student.getName());
}
}
public class Demo01{
private String name;
//get/set方法 alt + insert
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
继承
- 继承的本质是对某一批类的抽象
- extends “扩展”，子类是父类的扩展
- java中只有单继承，没有多继承
- 继承是类与类之间的一种关系，还有依赖、组合、聚类等关系
- 子类会继承父类的所有方法
学生is人子类 - 派生类父类 - 基类ctrl + h - 打开继承树
super
- super调用父类的构造方法，必须在构造方法的第一行出现
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
this
- 代表对象不同
- this：本身调用该类的对象
- super：代表父类对象的应用
- 前提
- this：没有继承也可以使用
- super：只要在继承条件下才可以使用
- 构造方法
- this()：本类的构造
- super(): 父类的构造
重写
需要有继承关系，子类重写父类的方法
规则：
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但是不能缩小 public > protected > default > private
- 抛出异常：范围，可以被缩小，但不能扩大 ClassNotFoundException > Exception
- 子类的方法和父类的必须要一致，方法体不同
为什么要重写？
- 父类的功能，子类不一定需要，或者不一定满足
方法的调用只和左边定义的数据类型有关
alt + insert: override
多态
动态编程： 类型 可扩展性
一个对象的实际类型是确定的
可以指向的引用类型是不确定的
多态的注意事项：
- 多态是方法的多态，属性没有多态
- 存在条件：继承关系，方法需要重写，父类引用指向子类的对象 Father f1 = new Sun();
- 对象能执行那些方法，主要看对象左边的类型
以下修饰符修饰后，方法不能重写
- static 属于类，不属于实例- final 常量- private方法
instanceof
判断一个对象是什么类型
判断两个类是否存在父子关系
- ok true- not ok false
类型转换
类型转换
基本类型（高低容量）
引用类型（高低-父类子类）
static关键字
静态变量 多线程
public static int age;
静态方法
public static void run(){}
代码块（匿名代码块）{
//创建对象自动创建在构造器之前
}
静态代码块
static{
//类加载执行，永久只执行一次
}
静态导入包
import static java.lang.Math;
final 修饰类不能被继承
public class student{
{
System.out.println("2");
}
static{
System.out.println("1");
}
public Student(){
System.out.println("3");
}
public static void main(String[] args){
Student student = new Student();
}
}
抽象类
- abstract修饰符可以修饰方法也可以修饰类 抽象方法 抽象类
- 抽象类中可以没有抽象方法，抽象方法一定要声明为抽象类
- 抽象类不可以用new关键字来创建对象，它是用来让子类继承的
- 抽象方法，只有方法的声明，没有方法的实例，方法是让子类实现的
- 子类继承抽象类，必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类
抽象类中可以写普通方法
抽象方法必须在抽象类中
单继承（接口可以多继承）
public abstract class Action{
public abstract void doSomething();
}
抽象类：abstract extends
接口： interface implements
接口
利用接口可以多继承
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！自己无法写方法-专业约束！约束和实现分离，面向接口编程
接口就是规范
接口的本质就是契约
OO的精髓是对对象的抽象，最能体现这一点的就是接口
声明类的关键字是class，声明接口的关键字是interface
接口的作用：
1. 约束
2. 定义了一些方法、让不同的人实现
3. public abstract 声明方法修饰符
4. public static final 声明变量修饰符
5. 接口不可以实例化，接口中没有构造方法
6. implements可以实现多个接口
//接口都需要实现类
public interface UserService{
int age = 99; //常量 public static final
//接口中的所有定义的方法其实都是抽象的 public abstract
void add(String name);
void delete(String name);
}
//实现了接口的类，就需要重写接口中的方法
public class UserServiceIml implements UserService{
@Override
public void add(String name){
}
@Override
public void delete(String name){
}
}
内部类
public calss Outer{
private int id = 10;
public void out(){
System.out.println("这是外部类的方法");
}
public static class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//static 修饰的内部类，无法获取外部类的私有属性
public void getID(){
}
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获取外部类的私有属性
public void getID(){
System.out.println(id);
}
}
public void method(){
//局部内部类
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类，但是只能有一个public class
class A{
main()方法
public void eat(){
System.out.println("吃");
}
}
interface UserService{
void hello();
}
public class Application{
public static void main(String[] args){
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.in();
//匿名内部类
new A().eat();
UserService userService = new UserService(){
@override
public void hello(){
}
};
}
}
异常处理
检查性异常：程序员无法预见的
运行时异常
错误
异常类 java.lang.Throwable
异常处理机制
- 抛出异常- 捕获异常
异常处理的五个关键字
try catch finally throw throws
try 监控区域
catch 捕获异常
finally 善后异常
捕获异常从小到大
ctrl + alt + T
try{
抛出异常
if (b**0){
throw new ArithmeticException(); //主动抛出异常，一般在方法中使用
}
}catch(Exception e){
// catch只执行一个
e.printStackTrace(); //打印错误的栈信息
}catch(){
}finaly{
}
方法上抛出异常
public void test() throws Exception{
}
public class Test{
public static void main(String[] args){
int a = 1;
int b = 0;
try{ //监控区域
System.out.println(a / b);
}catch(Exception e) { //捕获异常 catch（需要捕获的异常类型）
System.out.println("程序异常");
}catch(Throwable e){
System.out.println("throwable")；
}finally{ //无论有无异常都会执行，善后工作
System.out.println("finally");
}
}
}
自定义异常
用户自定义异常类，只需要继承Exception类即可
public class MyException throws Exception{
private int detail;
public MyException(int a){
this.detail = a;
}
@Override
public String toString(){
return "MyException{" + detail + "}";
}
}
扫一扫
3681
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
