面向对象编程
面向过程&面向对象
-
面向过程思想
- 步骤清晰简单,第一步做什么,第二步做什么
- 面对过程适合处理一些较为简单的问题
-
面向对象思想
- 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂问题,适合处理需要多人协作的问题。
-
对于描述复杂的事物,为了从宏观上把我、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作,仍然需要面向过程的思路去处理。
什么是面向对象
-
面向对象编程
-
面向对象编程本质是:以类的方式组织代码,以对象形式的组织(封装)数据。
-
抽象
-
三大特性:
- 封装
- 继承
- 多态
-
从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
-
从代码运行角度考虑是先有类后又对象。类是对象的模板。
类与对象的创建
创建与初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候,除了分片内存空间之外,还会给创建好的对象进行默认的初始化以及类中构造器的调用。
package com.oop.demo02;
//一个项目应该只有一个main()
public class Application {
public static void main(String[] args) {
//类,抽象的,需要实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Stundent类的具体实例
Stundent xiaoming = new Stundent();
xiaoming.name = "小明";
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
package com.oop.demo02;
//学生类
public class Stundent {
//属性:字段
String name;
int age;
//方法
public void study() {
System.out.println(this.name+"在学习");
}
}
- 类中的构造器也称为构造方法,是在进行创建对象的时候必须调用的。并且构造器有以下两个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void
package com.oop.demo02;
public class Person {
String name;
//实例化初始值
//使用new关键字,本质是调用构造器
public Person() {
this.name = "小白";
}
//有参沟槽:一旦定义了有参构造,无参构造就必须显示定义
public Person(String name) {
this.name = name;
}
/*
构造器:
1、和类名相同
2、没有返回值
作用:
1、new 本质在调用构造器
2、初始化对象的值
3、定义了有参构造后,如果想用无参构造,显示的定一个无参构造
*/
}
package com.oop.demo02;
//一个项目应该只有一个main()
public class Application {
public static void main(String[] args) {
//new 实例化一个对象
Person person = new Person();
Person person2 = new Person("小红");
System.out.println(person.name);
System.out.println(person2.name);
}
}
创建对象内存分析
详细请看:【转载】狂神说Java:Java零基础学习视频:面向对象06
封装详解
作用:
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高系统可维护性
追求:高内聚,低耦合(属性私有,get/set)
package com.oop.demo04;
//private :私有
public class Student {
//属性私有
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get、set的方法
public String getName() {
return this.name;
}
public String setName(String name) {
return this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age<0||age>120){
this.age = 3;
}else{
this.age = age;
}
}
}
package com.oop;
//一个项目应该只有一个main()
import com.oop.demo04.Student;
public class Application {
public static void main(String[] args) {
Student stundent = new Student();
stundent.setName("小白");
System.out.println(stundent.getName());
stundent.setAge(60);
System.out.println(stundent.getAge());
}
}
继承
-
继承的本质是对某一批类的抽象,从而实现对世界更好的建模
-
extends的意思是"扩展"。子类是父类的扩展。
-
JAVA中类只有单继承,没有多继承!
-
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
-
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示
-
子类和父类之间,从意义上讲应该具有“is a ”的关系。
-
不能继承final修饰的类
package come.xiaobai.oop.demo01; //人 :父类 public class Person { //public公共的 //protected受保护的 优先级从高到低依次往下 //default默认的 //private私有的 public int money = 10_0000_0000; public void say() { System.out.println("说了一句话"); } }
package come.xiaobai.oop.demo01; //学生is人 :子类,派生类 public class Student extends Person { //子类继承父类,就会拥有父类的全部方法 }
package come.xiaobai.oop; import come.xiaobai.oop.demo01.Student; public class Application { public static void main(String[] args) { //在java中,所有的类,都默认直接或间接继承object类 Student student = new Student(); student.say(); System.out.println(student.money); student.getClass();//继承object类的方法 } }
-
object类:在java中,所有的类,都默认直接或间接继承object类
-
super
- super调用父类的构造方法,必须在构造方法第一个
- super必须只能出现在方法或者构造方法中
- super和this不能同时调用构造方法
- 私有的private修饰符无法被继承
package come.xiaobai.oop.demo01;
//人 :父类
public class Person {
//public公共的
//protected受保护的 优先级从高到低依次往下
//default默认的
//private私有的
protected String name = "小白";
public void print() {
System.out.println("Person");
}
public Person() {
System.out.println("person无参构造执行了");
}
}
package come.xiaobai.oop.demo01;
//学生is人 :子类,派生类
public class Student extends Person {
//子类继承父类,就会拥有父类的全部方法
private String name = "77";
public void test(String name) {
System.out.println(name);//出入的参数
System.out.println(this.name);//子类name
System.out.println(super.name);//父类name
}
public void print() {
System.out.println("Student");
}
public void test1() {
print();//调用当前类print方法
this.print();//调用当前类print方法
super.print();//调用当父类print方法
}
public Student() {
//隐藏代码:
super();//调用父类构造器,必须在子类构造器之前
System.out.println("student无参构造执行了");
}
}
package come.xiaobai.oop;
import come.xiaobai.oop.demo01.Student;
public class Application {
public static void main(String[] args) {
//在java中,所有的类,都默认直接或间接继承object类
Student student = new Student();
System.out.println("=========================");
student.test("韩");
System.out.println("=========================");
student.test1();
}
}
- 方法重写
- 需要有继承关系,子类重新父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大不能缩小
- 抛出异常:可以被缩小,不能扩大
- 方法必须一致,方法体不同
package com.oop.demo05;
//重写都是方法的重写和类无关
public class B {
public void test() {
System.out.println("b---test");
}
}
package com.oop.demo05;
public class A extends B{
//重写
@Override//注解:有功能的注释
public void test() {
// TODO Auto-generated method stub
System.out.println("A---test");
}
}
package com.oop;
//一个项目应该只有一个main()
import com.oop.demo05.A;
import com.oop.demo05.B;
public class Application {
//静态方法和非静态方法区别很大
public static void main(String[] args) {
//方法的调用只和左边有关,即只和定义的数据类型有关
A a = new A();
a.test();
System.out.println("===============");
//父类的引用引用指向了子类
B b = new A();//子类重写了父类方法
b.test();
}
}
多态
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
- 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
- 多态存在条件
- 有继承关心
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:
- 多态是方法的多态,属性没有多态性
package com.oop.demo06;
public class Person {
public void run() {
System.out.println("person.run");
}
}
package com.oop.demo06;
public class Student extends Person {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("student.run");
}
public void eat(){
System.out.println("person.eat");
}
}
package com.oop;
//一个项目应该只有一个main()
import com.oop.demo06.Person;
import com.oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Person();
//new Student();
//可以指向的引用类型就不确定了:父类的引用指向子类
Student s1 = new Student();//student能调用的方法,都是自己的或者继承父类的
Person s2 = new Student();//person 父类型,可以指向子类,但是不能调用子类方法
Object s3 = new Student();
//对象能执行哪些方法,主要看左边的类型
s2.run();//子类重写了父类方法,执行子类方法
s1.run();
((Student) s2).eat();//强制转化,父类转子类 没有关系时转换异常:ClassCastException
}
}
-
instanceof (类型转换)引用类型,判断对象是什么类型
package com.oop;
//一个项目应该只有一个main()
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
public class Application {
public static void main(String[] args) {
Object s1 = new Student();
System.out.println(s1 instanceof Student);
System.out.println(s1 instanceof Person);
System.out.println(s1 instanceof Object);
System.out.println(s1 instanceof Teacher);
System.out.println(s1 instanceof String);
System.out.println("======================");
Person s2 = new Student();
System.out.println(s2 instanceof Student);
System.out.println(s2 instanceof Person);
System.out.println(s2 instanceof Object);
System.out.println(s2 instanceof Teacher);
System.out.println("======================");
Student s3 = new Student();
System.out.println(s3 instanceof Student);
System.out.println(s3 instanceof Person);
System.out.println(s3 instanceof Object);
System.out.println("======================");
}
}
- 类型转换
```java
package com.oop;
//一个项目应该只有一个main()
import com.oop.demo02.Stundent;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
public class Application {
public static void main(String[] args) {
//类型之间的转化
//高转低
Person s1 = new Student();
//student将这个对象转换成student类型,我们就可以使用student类型的方法了
Student s2 = (Student)s1;
s2.go();//(Student)s1.
//低转高 子类转为父类,可能丢失自己的本来的一些方法
Teacher s3 = new Teacher();
s3.eat();
Person s4 = s3;
s4.run();
}
}
static详解
- 静态和非静态变量及方法的调用
package com.oop.demo07;
//
public class Student {
private static int age;//静态变量
private double score;//非静态变量
public void run() {
}
public static void go() {
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.age);
System.out.println(s1.score);
System.out.println(Student.age);
//System.out.println(Student.score);不可以,编译报错,直接用类调用只能是静态的
System.out.println("====================================");
Student.go();
go();
s1.run();
}
}
- 静态和非静态代码块
package com.oop.demo07;
public class Person {
{
//代码块(匿名代码块)-----------其次执行,一般作用:赋初始值
System.out.println("匿名");
}
static{
//静态代码块(匿名代码块)-----------首先执行,且只执行一次
System.out.println("静态");
}
public Person() {
//构造方法-----------最后执行
System.out.println("构造器");
}
public static void main(String[] args) {
Person person = new Person();//结果:静态、匿名、构造
System.out.println("===================");
Person person1 = new Person();//结果:匿名、构造
}
}
package com.oop.demo07;
//静态导入包
import static java.lang.Math.random;
public class Teacher {
public static void main(String[] args) {
System.out.println(random());
}
}
抽象类
- abstract修饰符来修饰
- 抽象类:约束,不能实现,只能子类来实现它
- 类里面有抽象方法,类必须为抽象类
- 抽象类中可以有普通方法。
- 抽象类的所有方法,继承了他的子类,都必须要实现他的方法,除非子类子类也是抽象的
package com.oop.demo08;
//抽象类
public abstract class Action {
//约束~有人帮我们实现
//抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
/*
1、抽象类:约束,不能实现,只能子类来实现它
2、类里面有抽象方法,类必须为抽象类
3、抽象类中可以有普通方法。
思考:
1、抽象类,不能new,是否有构造器-------有
2、存在的意义--------提高开发效率
*/
public Action() {
System.out.println("抽象类中的构造器");
}
}
package com.oop.demo08;
//抽象类的所有方法,继承了他的子类,都必须要实现他的方法,除非子类子类也是抽象的
public class A extends Action{
@Override
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("查看构造体");
}
}
package com.oop;
//一个项目应该只有一个main()
import com.oop.demo08.A;
public class Application {
public static void main(String[] args) {
A a = new A();
}
}
接口的定义与实现
类、抽象类、接口区别
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有!
- 接口:只有规范!
接口定义
- 接口就是规范,定义的是一组规则,体现了显示世界中“如果你是。。。则必须能。。。”的思想。如果你是天使,必须能飞。如果你是汽车,则必须能跑。
- 接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
- OO的精髓,是对对象的抽象,最能体现这一点的就是接口。为什们我们讨论设计模式都是针对具备了抽象能力的语言,就是因为设计模式所研发的,实际上就是如何合理的去抽象。
- 声明关键字:interface
接口作用
- 约束
- 定义一下方法,让不同的人实现
- 定义方法:void go();//public abstract void go(); 默认隐藏public abstract
- 定义常量:int age = 99;//与 public static final int age = 99;相同
- 接口不能被实例化,接口中没有构造方法
- implements 可以实现多个接口
- 实现接口的类必须要重写接口中的方法
package com.oop.demo09;
//interface定义的关键字,接口都需要有实现类
//接口不能把被实例化,没有构造方法
public interface UserService {
//接口中的所有定义其实都是抽象的 public
public abstract void run();
void go();//public abstract void go(); 默认隐藏public abstract
void add(String name);
void delet(String name);
//常量
int age = 99;//与 public static final int age = 99;相同,
}
package com.oop.demo09;
public interface TimeService {
void timer();
}
package com.oop.demo09;
//implements来实现接口
//实现接口的类必须重写接口中的方法
//接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
// TODO Auto-generated method stub
}
@Override
public void delet(String name) {
// TODO Auto-generated method stub
}
@Override
public void go() {
// TODO Auto-generated method stub
}
@Override
public void run() {
// TODO Auto-generated method stub
}
@Override
public void timer() {
// TODO Auto-generated method stub
}
}
内部类
-
定义:内部类就是在一个类内部在定义一个类,比如:A类中定义一个B类,那么B累相对A类来说就成为内部类,而A类相对B类来说就是外部类
-
分类
- 成员内部类
package com.oop.demo10; public class Outer { private int id = 10; public void out() { System.out.println("这是外部类的方法"); } /** * InnerOuter */ public class Inner{ public void in() { System.out.println("这是内部类的方法"); } //内部类获得外部类的私有属性 public void getId() { System.out.println(id); } } }
package com.oop; //一个项目应该只有一个main() import com.oop.demo10.Outer; public class Application { public static void main(String[] args) { Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); inner.getId(); } }
-
静态内部类---增加static修饰符,无法获取外部类变量,因为static先执行
-
局部内部类
-
匿名内部类