面向对象
1.初识面向对象
面向过程&面向对象
属性+方法=类
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是具体到围观操作，仍然需要面向过程的思路去处理。
什么是面向对象
面向对象编程（Object-Oriented Programming，OOP）
本质:以类的方式组织代码，以对象的方式组织（封装）数据
抽象
三大特性：封装 继承 多态
从认识论角度是现有对象后有类。对象是具体的事物，类是抽象的，是对对象的抽象
从代码运行的角度考虑是先有类后有对象。类是对象的模板。
2.方法回顾和加深
- 方法的定义
修饰符
返回类型
break跳出switch 和return跳出循环 的区别
方法名 驼峰规则和见名知意
参数列表 （参数类型，参数名）...
异常抛出
- 方法的调用:递归
静态方法 static
非静态方法 无static
形参和实参
值传递和引用传递 ：值传递：形参和实参在内存上是独立的两个变量。引用传递：实参和形参在内存上指向同一个地址。
this关键字
3.对象的创建分析
类与对象的关系
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
对象是抽象概念的具体实例
创建与初始化对象
-
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化，记忆对类中构造器的调用。
-
类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。并且构造器有以下两个特点
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
//java文件
public class Person {
//一个类即使什么都不写，它也会存在一个方法
}
//calss文件
public class Person {
public Person() {
}
}
package com.oop.demo02;
public class Person {
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new关键字，本质是在调用构造器
//2.用来初始化值
//无参构造器
public Person() {
// this.name="YY";
}
//有参构造器：一旦定义了有参构造，无参就必须显示定义
public Person(String name) {
this.name=name;
}
String name;
//alt+insert -----》construction
int age;
public Person() {
}
public Person(String name) {
this.name = name;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
package com.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//实例化一个对象
Person person = new Person("yy");
System.out.println(person.name);
}
}
构造器：1.和类名相同 2.没有返回值
作用：1.new本质在调用构造方法 2.初始化对象的值
注意点：定义有参构造之后，一定显示的定义一个无参构造
//alt+insert -----》construction
this. 是当前类的 =一般是形参
小结
-
类与对象
类是一个模板：抽象，对象是一个具体的实例
-
方法 定义和调用
-
对应的引用
引用类型：基本类型（8） byte short int long float double boolen char
对象是用过引用来操作的：栈——》堆
-
属性：字段field 成员变量
默认初始化：
数字 0 0.0
char u0000
boolean：false
引用：null
修饰符 属性类型 属性名 =属性值
-
对象的创建和使用
-
必须使用new关键字创造对象，构造器 Person Y=new Person（）；
-
对象的属性 Y.name
-
对象的方法 Y.study（）
-
-
类
静态的属性 属性
动态的行为 方法
4. 面向对象的三大特征
封装
高内聚，低耦合。高内聚：内部数据操作细节自己完成不允许外币干涉 低耦合：紧暴露少量的方法给外部使用。
属性私有，get/set。
-
提高程序的安全性，保护数据
-
隐藏代码的实现细节
-
统一接口
-
系统可维护增加了
继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extands的意思是扩展。子类是父类的扩展。
java中只有单继承，没有多继承！
object 类 ：在java中，所有的类都默认直接或者间接继承object 类
super -this ：super. 子类继承父类的方法，父类私有方法无法被继承
//父类
public Person(){
System.out.println("Person无参构造器");
}
//子类
public class Teacher extends Person {
public Teacher(){
//隐藏代码：默认调用了父类的无参构造 super(); 父类的无参构造 写的的话必须在第一行
System.out.println("techer无参构造器");
}
}
//应用类
Teacher teacher = new Teacher();
//执行结果
Person无参构造器
techer无参构造器
super注意点
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类的方法或者构造方法中
-
super和this不能同时调用构造方法
VS this：
-
代表的对象不同
this：本身调用者这个对象
super：代表父类的应用
-
前提
this：没有继承也可以使用
super：只能在继承条件下才可以使用
-
构造方法
this（）；本类的构造
super（）；父类的构造
方法重新------》多态
重写：需要有继承关系，子类重写父类的方法！
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大：public>Protected>Default>private
- 跑出的异常：范围可以被缩小，但是不能扩大。ClassNotFoundExpection->Exception(大)
重写子类的方法和父类必需要一致，方法体不同
为什么需要重写？
-
父类的功能子类不一定需要或者满足 alt+insert ：override
//重新都是方法的重新和属性无关 public class B { public void test() { System.out.println("B==>TEST"); } } public class A extends B{ @Override public void test() { // super.test(); System.out.println("A==>TEST"); } } public class Application { public static void main(String[] args) { //静态的方法和非静态的方法区别很大 /* 静态的方法：方法的调用只和左边，定义的数据类型有关 非静态的方法：子类重写了父类的方法 * */ // A a=new A(); a.test();//A B b =new A();//static:父类的引用指向了A b.test();//B } A==>TEST A==>TEST AB都是static方法 A==>TEST B==>TEST
多态
动态编译：类型可扩展性
-
方法的多态，属性没有多态
-
父类和子类，有联系 ，类型转换异常 ClassCastException
-
存在条件：继承关系，相同的子类方法会被重新，父类的引用指向子类对象。father f1=new son（）；
以下方法无法重写：
-
static 方法属于类，不属于实例
-
final 常量
-
private方法
-
instanceof 类型转换 引用类型 ，判断一个对象是什么类型
- 父类的引用指向子类的对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型：强制转换
- 方便方法的调用，减少重复的代码
Static关键字
static随类一起加载，非static随实例一起加载
public class StaticTest {
//2
{
System.out.println("匿名代码块");//赋一些初始值
}
//1
static {
System.out.println("静态代码块");//只执行一次，第一次执行
}
//3
public StaticTest(){
System.out.println("构造方法");
}
public static void main(String[] args) {
StaticTest staticTest1= new StaticTest();
System.out.println("============");
StaticTest staticTest2 = new StaticTest();
}
}
静态代码块
匿名代码块
构造方法
============
匿名代码块
构造方法
import static java.lang.Math.random;//静态导入包
5. 抽象类和接口
abstract 抽象类
extends ：单继承（ 接口可以多继承）
-
不能new这个抽象类，只能考子类去实现它：约束！
-
抽象类中可以写普通方法
-
抽象方法必须在抽象类中
-
抽象的抽象：约束
节省代码开发提高开发效率
接口
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范。约束和实现的分离：面向接口编程
声明类的关键字是class 声明接口的关键字是interface
作用：
-
约束
-
定义方法，让不同的人实现
-
public abstract
-
public static final
-
接口不能被实例化，接口中没有构造方法
-
implement可以实现多个接口
-
必须重写接口中的方法
public interface UserService { void add(String name); } public interface TimeService { void timer(); } public class UserServiceImpl implements UserService,TimeService{ @Override public void add(String name) { } @Override public void timer() { } }
6. 内部类及oop实战
内部类就是在一个类的内部再定义一个类，比如A类中定义一个B类，那么B类相对于A类来说就称为内部类，A对于B来说是外部类
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类