什么是面向对象
-
面向对象编程(oop):(Object-Oriented Programming
-
过程(流程)&对象(框架)
1.面向过程思想
步骤清晰简单,第一步做什么,第二步做什么…
面对过程适合处理一些较为简单的问题
2.面向对象思想
物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题,适合处理需要多人协作的问题! -
面向对象编程的本质:以类的方式组织代码,以对象的组织(封装)数据。
-
三大特点:继承(子类父类),封装(留一个小接口),多态(同一事物多种形态)
-
先有对象后有类:对象(一堆人),类(这些人的共同点)
方法定义
- class 修饰的为类,main方法
/*修饰符 返回值类型 方法名(...) {
方法体
return 返回值;
}*/
public string sayHello(){
return "he1lo,world" ;
}
public int max(int a,int b){
return a>b ? a : b; //三元运算符!
}
- break&return
break:跳出switch,结束循环
return结束方法,返回一个结果! - 方法名:注意规范就OK见名知意
- 参数列表:(参数类型,参数名)–,可变参数(之前讲过)
- 异常抛出:疑问,后面讲解
方法调用
- 分离程序
- 静态变量(static)调用:类名.方法名
- 非静态:实例化(New).类名.方法名
- 形参&实参
- 值传递&引用传递
//值传递
public class Demo04 {
public static void main( String[] args) {
int a = 1;
system.out.println(a) ;
Demo04.change(a);
System.out.println(a); //1
}
//返回值为空
public static void change(int a){
a = 10;
}
}
//引用传递:对象,本质还是值传递
public class Demo05 {
public static void main( String[] args) {
Perosn perosn = new Perosn();
system.out.println(perosn.name);//null
Demoo5.change(perosn);
system.out.print1n(perosn.name);//秦疆
}
public static void change(Perosn perosn){
perosn.name ="秦疆";
}
}
//定义了一个Perosn类,有一个属性: name
class Person{
string name; //null
}
类与对象的创建
- 创建类
//学生类
public class student {
//属性:字段
string name;
int age;
//方法
public void study(){
System.out.println(this.name+在学习");
}
}
- 使用new创建对象
//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args){
//类:抽象的,实例化类实例化后会返阿一个自己的对象!
//student对象就是一个Student美的具体实例!
Student xiaoming = new Student();
Student xiaohong = new Student();
xiaoming.name =“小明";
xiaoming.age = 3;
System.out.println(xiaoming.name) ;
}
}
- 以类的方式组织代码,以对象的组织(封装)数据。
构造器
java文件→生成class文件:idea可查看
- 定义构造器
1.必须和类的名字相同
2.必须没有返回类型,也不能写void
/ /java ---> class
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显示的定义构造器
string name;
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Person(){
}
//3.有参构造:一旦定义了有参构造,无参就必须显示定义public Person(String name){
this.name = name;
}
}
- 生成构造器快捷键:
无参:alt+insert-selectno
有参:alt+insert-ok - this.=传递值
内存分析
易于理解图
- 栈:存储方法名和引用变量
- 堆:存放具体创建出来的对象
包含方法区,方法区中有静态变量(可以直接调用)
小结
1.类与对象
-类是一个模板:抽象,对象是一个具体的实例
2. 方法
-定义、调用!
3.对应的引用
-引用类型:基本类型(8)
-对象是通过引用来操作的:栈—>堆
4.属性:字段Field 成员变量
-默认初始化:
-数字:0.0
-char : u0000
-booLean :false
-引用: null
-修饰符 属性类型 属性名=属性值!
5.对象的创建和使用
-必须使用new关键字创造对象,构造器Person kuangshen = new Person( );
-对象的属性kuangshen.name
-对象的方法kuangshen.sleep( )
6.类:
-静态的属性属性动态的行为方法
封装
- 高内聚,低耦合:高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
- 属性私有 get/set
s1.setName(”秦疆""); - 快捷键:alt+insert
//类private:私有
public class Student {
private String name; //名字
private int id; //学号
private char sex; //性别
//提供一些可以操作这个属性的方法!
//提供一些public 的get、set方法
//get获得这个数携
public String getName()i
return this.name;
}
//set给这个数据设置值
public void setName( String name){
this.name = name;
}
}
- 作用
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了 - 重载
方法名同,参数不同
继承
- extends
- JAVA中类只有单继承(直接继承),没有多继承(间接继承祖宗类)!
- //public //protected// default // private
- 快捷键:ctrl+h
- 在java中,所有的类,都默认直接或者间接继承object
super(继承)
- super&this
- 代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的 - 应用前提
this:没有继承也可以使用
super:只能在继承条件才可以使用 - 构造方法
this();本类的构造
super():父类的构造!
- 无参:()内无参数
- super注意点
- super调用父类的构造方法,必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中!
- super和this 不能同时调用构造方法!
方法重写(继承)
-
重载&重写:
重载:方法同,参数不同
重写:方法同,参数也同 -
重写(override)小结:
-1. 需要有继承关系,子类重写父类的方法!
-2. 方法名必须相同
-3. 参数列表列表必须相同
-4. 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
-5. 抛出的异常:范围,可以被缩小,但不能扩大:ClassNotFoundException -->Exception(大)
-6. 方法前不加static,为非静态的
-7. 重写,子类的方法和父类必要一致:方法体不同!
-8. 父类的功能,子类不一定需要·或者不一定满足!
-9. Alt+Insert : override:
多态
//一个对象的实际类型是确定的
//new student();
//new Person();
//可以指向的引用类型就不确定了,父类的引用指向子类
//Student能调川的方法都是自己的或者维承父类的!
Student s1 = new Student();
// Person父类型,可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
- 多态注意事项:
1.多态是方法的多态,属性没有多态
2.父类和于类,有联系类型转换异常! ClassCastException!
3.存在条件:维承关系, 方法需要重写,父类引用指向子类对象! Father f1 = new Son();
4.不能重写的:static方法,属于类,它不属于实例;final常量;private方法;
instanceof&类型转换(多态)
- System.out.println(x instanceof Y);能不能编译通过!:看x和y的关系
- 类型转换
- 小结:
1.父类引用指两子类的对象
2.把了类转换为父类,向上转型:
3.把父类转换为于类,向下转型;强制转换
4.方便方法的调用,减少重复的代码!简洁
static关键字
- 不是静态变量:需要new类,在调用;静态变量:可以直接调用
- 非静态变量可以调用静态变量,静态变量不可以调用非静态变量
- 代码块
- 执行顺序:静态代码块 (只执行一次) ,匿名代码块(可用来赋初始值),构造方法
- 静态导入包
import static java.lang.Math .random; - 类被final修饰,则不能继承
抽象类
- 在类前加abstract-抽象类
- 在方法前加abstract-抽象方法
- 抽象类的所有方法,继承了它的子类,都必须要实现它的方法~,抽象父类中的方法为约束,不需要自己实现。
- 注意
1.不能new这个抽象类,只能靠子类去实现它;约束!
2.抽象类中可以写普通的方法~
3.抽象方法必须在抽象类中~
接口(interface)的定义与实现
- 接口可以多继承
- 接口本质是契约
- 抽象:abstract,extends;接口:interface,implement
- 接口中定义方法
- 小结
1实现约束
2定义一些方法,让不同的人实现~10—>1(10个人实现一种方法)
3所有方法都是 public abstract
4所有常量都是 public static final
5接口不能被实例化~(new),接口中没有构造方法~
6implements可以实现多个接口
7必须要重写接口中的方法~
N钟内部类
- 内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。|
1.成员内部类
⒉静态内部类
3.局部内部类
4.匿名内部类 - 内部类:类里的类
- 一个java类中可以有多个cLass类,但是只能有一个public cLass
- 局部内部类:类里的方法的类
- 匿名内部类:没有名字