Day6 笔记 面向对象
6.1 面向过程与面向对象
面向过程的思维方式：
面向过程的思维方式是简单的线性思维，思考问题首先陷入第一步做什么，第二步做什么，这种思维模式适合处理简单的事情
面向对象的思维模式：
面向对象的思维模式就是分类思维模式。思考问题首先会解决问题需要哪些分类，然后对分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索
6.2 什么是面向对象
JAVA的编程语言是面向对象，采用这种语言进行编程称为面向对象编程。
面向对象编程的本质就是：以类的方式组织代码，以对象的组织封装数据
抽象（abstract）
忽略一个主题中与当前目标无关的那些方面
封装（encapsulation)
封装是面向对象的特征之一，是对象和类概念的主要特征。封装是把数据和过程包围起来，对数据的访问只能通过指定的方式。
继承（inheritance）
继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确的描述共性的方法新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。
多态（polymorphism）
多态性是指允许不同类的对象对同一消息作出响应。
6.2 类与对象的关系
类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。
对象是抽象概念的具体
Student s = new Student(1L,"tom",20);
s.study();
Car c = new Car(1,"BWM",500000);
c.run();
对象s就是Student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。类只是给对象的创建提供了一个参考的模板而已…3
6.3 方法的定义
格式： 修饰符 返回类型 方法名
修饰符
public、static、abstract、final等等都是修饰符，一个方法可以有多个修饰符。例如程序入口main方法，就使用了public static这个俩个修饰符
注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的
返回类型
方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必须写void.
只有构造方法(构造器)不写任何返回类型也不写void
public String sayHello(){
return "hello";
}
public int max(int a,int b){
return a>b?a:b;
}
public void print(String msg){
System.out.println(msg);
}
方法名
遵守java中标示符的命名规则即可
参数列表
根据需求定义,方法可以是无参的,也可以有一个参数,也可以有多个参数
异常抛出类型
如果方法中的代码在执行过程中,可能会出现一些异常情况,那么就可以在方法上把这些异常声明并抛出,也可以同时声明抛出多个异常,使用逗号隔开即可。
方法的调用
1.非静态方法
没有使用static修饰符修饰的方法,就是非静态方法.
调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)
public class Student{
public void say(){}
}
main:
Student s = new Student();
s.say();
2.静态方法
使用static修饰符修饰的方法,就是静态方法.
3.类中方法之间的调用,a和b都是非静态方法
public void a(){
b();
}
public void b(){
}
a和b都是静态方法，相互之间可以直接调用
public static void a(){
b();
}
public static void b(){
}
a是静态方法，b是非静态方法，a不能直接调用b，但是b可以直接调用a。
public static void a(){
//b();报错
}
public void b(){
a();
}
调用方法时的传参
参数列表中的a是方法test的形参
调用方法时x是方法text的实参
this关键字
1，this在类中的作用
public class Student{
private String name;
public void setName(String name)
this.name = name
}
调用类中的其他方法
public class Student{
private String name;
public void setName(String name)
this.name = name;
}
public void print(){
this.setName("tom");
}
}
2.this关键字在类中的意义
this在类中表示当前类将来创建出的对象
6.4 创建与初始化对象
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化 以 及对类中构造器的调用。
Student s = new Student()
构造器
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void
构造器的作用:
- 使用new创建对象的时候必须使用类的构造器
- 构造器中的代码执行后,可以给对象中的属性初始化赋值
public class Student{
private String name;
public Student(){
name = "tom";
}
}
构造器重载
除了无参构造器之外,很多时候我们还会使用有参构造器,在创建对象时候可以给属性赋值.
public class Student{
private String name;
public Student(){
name = "tom";
}
public Student(String name){
this.name = name;
}
}
构造器之间的调用
public class Student{
private String name;
public Student(){
this();
}
public Student(String name){
this.name = name;
}
}
6.5封装
封装白话：该露的露，该藏的藏
封装（数据的隐藏）
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
封装的步骤
-
使用private 修饰需要封装的成员变量。
-
提供一个公开的方法设置或者访问私有的属性
设置 通过set方法，命名格式： set属性名（）; 属性的首字母要大写3.访问 通过get方法，命名格式： get属性名（）; 属性的首字母要大写
//对象能在类的外部"直接"访问
public class Student{
public String name;
public void println(){
System.out.println(this.name);
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.name = "tom";
}
}
public class Student{
private String name;
}
public class Test{
public static void main(String[] args){
Student s = new Student();
//编译报错,在类的外部不能直接访问类中的私有成员
s.name = "tom";
}
}
//set负责给属性赋值
//get负责返回属性的值
public class Student{
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.setName("tom");
System.out.println(s.getName());
}
}
5.8 继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
继承
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
public class student extends Person{
}
3.子类和父类之间,从意义上讲应该具有"is a"的关系.
tudent is a person
dog is a animal
4.类和类之间的继承是单继承
Object类
JAVA中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。
Super关键字
子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法。
访问父类中的属性
public class Person{
protected String name = "zs";
}
public class Student extends Person{
private String name = "lisi";
public void tes(String name)t{
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
调用父类中的方法
public class Person{
public void print(){
System.out.println("Person");
}
}
public class Student extends Person{
public void print(){
System.out.println("Student");
}
public void test(){
print();
this.print();
super.print();
}
}
方法重写
方法的重写（override）
- 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.
- 静态方法不能重写
- 父类的静态方法不能被子类重写为非静态方法 //编译出错
- 父类的非静态方法不能被子类重写为静态方法；//编译出错
- 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
多态
多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。
多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性。
允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
相同类域的不同对象,调用相同的方法,执行结果是不同的
一个对象的实际类型是确定的
例如: new Student(); new Person();等
可以指向对象的引用的类型有很多
一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种。
例如: Student继承了Person类
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
因为Person和Object都是Student的父类型
注:一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型。
多态中的方法调用
public class Person{
public void run(){}
}
public class Student extends Person{
}
调用到的run方法,是Student从Person继承过来的run方法
main:
Person p = new Student();
p.run();
多态的注意事项
- 多态是方法的多态，属性没有多态性。
- 编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。 比如：本来是狗，我把它转成猫。就会报这个异常。
- 多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象
多态存在的条件
-
有继承关系
-
子类重写父类方法
-
父类引用指向子类对象
补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：
-
static方法，因为被static修饰的方法是属于类的，而不是属于实例的
-
final方法，因为被final修饰的方法无法被子类重写
-
private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢
修饰符
static变量
在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。
静态变量和非静态变量的区别
静态变量属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问.
public class Student{
private static int age;
private double score;
public static void main(String[] args) {
Student s = new Student();
//推荐使用类名访问静态成员
System.out.println(Student.age);
System.out.println(s.age);
System.out.println(s.score);
}
}
static方法
静态方法和非静态方法的区别
静态方法数属于类的,"可以"使用类名来调用,非静态方法是属于对象的,"必须"使用对象来调用.
静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态方法
注意:this和super在类中属于非静态的变量.(静态方法中不能使用)
非静态方法"可以"直接访问类中的非静态变量和非静态方法,也"可以"直接访问类中的静态变量和静态方法
final修饰符
1、修饰类
用final修饰的类不能被继承,没有子类。
例如:我们是无法写一个类去继承String类,然后对String类型扩展的,因为API中已经被String类定义为final的了.
public final class Action{
}
//编译报错
public class Go extends Action{
}
修饰方法
用final修饰的方法可以被继承,但是不能被子类的重写。
例如:每个类都是Object类的子类,继承了Object中的众多方法,在子类中可以重写toString方法、equals方法等,但是不能重写getClass方法 wait方法等,因为这些方法都是使用fianl修饰的。
我们也可以定义final修饰的方法:
public class Person{
public final void print(){}
}
//编译报错
public class Student extends Person{
public void print(){
}
}
修饰变量
用final修饰的变量表示常量,只能被赋一次值.其实使用final修饰的变量也就成了常量了,因为值不会再变了。
public class Person{
public void print(final int a){
//编译报错,不能再次赋值,传参的时候已经赋过了
a = 1;
}
}
public class Person{
public void print(){
final int a;
a = 1;
//编译报错,不能再次赋值
a = 2;
}
}
abstract修饰符
abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
1、抽象类和抽象方法的关系
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
2、语法
public abstract class Action{
public abstract void doSomething();
}
public void doSomething(){...}
3、特点及作用
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
接口
普通类：只有具体实现
抽象类：具体实现和规范(抽象方法) 都有！
接口：只有规范！
- 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
- 抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。
- 从接口的实现者角度看，接口定义了可以向外部提供的服务。
- 从接口的调用者角度看，接口定义了实现者能提供那些服务。
- 接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。
接口的本质探讨
-
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。
-
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
-
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
接口与抽象类的区别
抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口。
声明类的关键字是class,声明接口的关键字是interface。
抽象类是用来被继承的,java中的类是单继承。
类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态
一个父类的引用,可以指向这个父类的任意子类对象
注:继承的关键字是extends接口是用来被类实现的,java中的接口可以被多实现。
类A实现接口B、C、D、E…,那么类A的对象就属于B、C、D、E等类型了,可以使用多态
一个接口的引用,可以指向这个接口的任意实现类对象
注:实现的关键字是implements
扫一扫
3374
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
