面向对象编程（OP）

您所在的位置：网站首页 › 约束编程是什么意思 › 面向对象编程（OP）

面向对象编程（OP）

2024-07-16 11:04| 来源: 网络整理| 查看: 265

面向对象编程（OP） 1.初始面向对象（OOP）

本质：以类的方式组织代码，以对象的组织（封装）数据。

三大特性：封装、继承、多态

2.方法回顾和加深

方法的定义：

break 跳出循环

return 结束

package com.OOP; import java.io.IOException; //Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { } /* 修饰符返回值类型方法名（……）{ //方法体 return 返回值； } */ //return 结束方法，返回一个结果 public static String sayhello(){ return"hello world!"; } public int max(int a,int b){ return a>b?a:b; } //数组下标越界 public void readFile(String file)throws IOException{ } }

方法名：注意规范，

参数列表：（参数类型，参数名）……

异常抛出

方法的调用

静态方法

非静态方法

package com.OOP; public class Demo02 { public static void main(String[] args) { //静态方法 static //实例化这个类new //对象类型对象名=对象值 Student student = new Student(); student.say(); } } package com.OOP; //学生类 public class Student { // //非静态方法 public void say(){ System.out.println("学生说话了"); } }

形参和实参

package com.OOP; public class Demo03 { public static void main(String[] args) { int add=Demo03.add(1,2); System.out.println(add); } public static int add(int a, int b){ return a+b; } }

值传递和引用传递

package com.OOP; //值传递 public class Demo04 { public static void main(String[] args) { int a=1; System.out.println(a);//1 Demo04.change(a); System.out.println(a);//1 } //返回值为空 public static void change(int a){ a=10; } } package com.OOP; //引用传递：对象，本质还是值传递 public class Demo05 { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name);//null Demo05.change(person); System.out.println(person.name); } public static void change(Person person){ //person是一个对象：指向的----> Person person = new Person();这是一个具体的人，可以改变属性 person.name="小蜜蜂"; } //定义了一个Person类，有一个属性：name static class Person{ String name;//NULL } }

this关键字

3.对象的创建分析使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类构造器的调用

类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的，并且构造器有以下两个特点：

必须和类的名字相同必须没有返回类型,也不能写void package com.OOP.Demo02; //学生 public class Students { //属性：字段 String name; int age; public void study(){ System.out.println(this.name+"在学习"); } } package com.OOP.Demo02; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { //类：抽象的，实例化 //类实例化后会返回一个自己的对象 //students对象就是一个Students类的具体实例 Students xiaoming = new Students(); Students xiaohong = new Students(); xiaoming.name="小明"; xiaohong.name="小红"; xiaoming.age=3; xiaohong.age=3; System.out.println(xiaoming.name); System.out.println(xiaohong.name); System.out.println(xiaoming.age); System.out.println(xiaohong.age); } } 构造器必须掌握 package com.OOP.Demo02; //java……>class public class Person { //一个类即使什么都不写，也会存在一个方法 String name; //显示的定义构造器 //实例化初始值 //1.使用new关键字，必须要有构造器 /* public Person(){ this.name="小蜜蜂"; } */ public Person(){ } //有参构造:一旦定义了有参构造，无参就必须显示定义 public Person(String name){ this.name=name; } //alt+insert 生产构造器 /* 构造器 1.和类名相同 2.没有返回值作用： 1.new本质在调用构造函数 2.初始化对象值注意点： 1.定义有参构造之后，想要使用无参构造，显示的定义的一个无参的构造 Alt+Insert this.= */ } package com.OOP.Demo02; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { //new 实例化的一个对象 //Person person= new Person(); Person person= new Person("小蜜蜂"); System.out.println(person.name); } } package com.OOP.Demo03; public class Pet { public int age; public String name; //无参构造 public void shout(){ System.out.println("叫了一声"); } } package com.OOP; import com.OOP.Demo03.Pet; public class Application { public static void main(String[] args) { Pet dog= new Pet(); dog.name="旺财"; dog.age=3; dog.shout(); System.out.println(dog.name); System.out.println(dog.age); } } /* 1.类与对象类是一个模板，抽象对象是一个具体的实例 2.方法定义，调用！ 3.对应的引用引用类型：基本类型（8）对象是通过引用来操作的：栈--->堆 4.属性：字段Field 成员变量默认初始化数字：0 0.0 char：u0000 Boolean：false 引用：NUll 修饰符属性类型属性名=属性值！ 5.对象的创建和使用必须使用new 关键字创造对象，构造器 Person xiaoming=new Person 对象的属性xiaoming.name 对象的方法：xiaoming.sleep() 6.类静态的属性属性动态的行为方法 *封装、继承、多态* */ 4.面向对象三大特性封装

“高内聚，低耦合”：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合仅暴露少量的方法给外部使用

通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

属性私有，get/set

package com.OOP.Demo04; /* 1.提高程序的安全性，保护数据 2.隐藏代码的实现细节 3.统一接口 4.提高系统的可维护性 */ public class Application { public static void main(String[] args) { Student s1= new Student(); s1.setName("小蜜蜂"); System.out.println(s1.getName()); s1.setAge(-1);//不合法 System.out.println(s1.getAge()); } } package com.OOP.Demo04; public class Student { //属性私有 private String name;//名字 private int id; //学号 private char sex;//性别 private int age;//年龄 //提供一些可以操作这个属性的方法 //提供一些public 的get.set方法 //get 获得这个数据 public String getName(){ return this.name; } //set 给这个数据设置值 public void setName(String name){ this.name=name; } //alt+insert public int getId() { return id; } public void setId(int id) { this.id = id; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { if (age > 120 || age this.age = age; } } } 继承

继承本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思是“扩展”，子类是父类的扩展

Java中类只有单继承，没有多继承！

继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等

继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示

子类和父类之间，从意义上讲应该具有“is a”的关系

object类

package com.OOP.Demo05; //在Java中，所有的类，都默认直接或者间接继承Object //Person 人:父类 public class Person { //public 公共的 //protected 安全的 //default 默认的 //private 私有的 private int money=10_0000_0000; public void say(){ System.out.println("说了一句话"); } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } } package com.OOP.Demo05; //Teacher是人：派生类，子类 public class Teacher extends Person{ } package com.OOP.Demo05; //学生 is 人：派生类，子类 //子类继承了父类，就会拥有父类和全部方法 public class Student extends Person{ //ctrl+H } package com.OOP.Demo05; public class Application { public static void main(String[] args) { Student student= new Student(); student.say(); System.out.println(student.money); } }

super

package com.OOP.Demo05; //在Java中，所有的类，都默认直接或者间接继承Object //Person 人:父类 public class Person/*extends Object*/ { protected String name="小蜜蜂"; public void print(){ System.out.println("Person"); } } package com.OOP.Demo05; //学生 is 人：派生类，子类 //子类继承了父类，就会拥有父类和全部方法 public class Student extends Person{ //ctrl+H private String name="大蜜蜂"; //私有的东西无法被继承 //隐藏代码：调用了父类的无参构造 //super（）；调用父类的构造器，必须要在子类构造器的第一行 //this（）；调用父类的构造器，必须要在子类构造器的第一行 public void print(){ System.out.println("Student"); } public void test1(){ print();//Student this.print();//Student super.print();//Person } public void test(String name){ System.out.println(name);//xiaomifeng System.out.println(this.name);//大蜜蜂 System.out.println(super.name);//小蜜蜂 } } package com.OOP.Demo05; public class Application { public static void main(String[] args) { Student student= new Student(); //student.test("xiaomifeng"); student.test1(); } } package com.OOP.Demo05; //Teacher是人：派生类，子类 public class Teacher extends Person{ } super注意点： 1.super调用父类的构造方法，必须在构造方法的第一个 2.super必须只能出现在子类的方法或者构造方法中！ 3.super和this不能同时调用构造方法 Vs this：代表的对象不同： this:本身调用者这个对象 super：代表父类对象的引用前提： this：没有继承也可以使用 super：只能在继承条件下才能使用构造方法: this();本类的构造 super()；父类的构造

方法重写

package com.OOP.Demo05; import com.sun.xml.internal.ws.addressing.WsaActionUtil; public class A extends B { /* public void test(){ System.out.println("A=>test()"); } */ //Override 重写 @Override//注释：有功能的注释！ public void test() { System.out.println("A>=test()"); } } package com.OOP.Demo05; //继承 public class Application { //静态的方法和非静态的方法区别很大！ //静态方法：方法的调用只和左边，定义的数据类型有关 //非静态方法：重写 public static void main(String[] args){ A a=new A(); a.test();//A //父类的引用指向了子类 B b=new A();//子类重写了父类的方法 b.test();//B } } package com.OOP.Demo05; //重写都是方法的重写，和属性无关 public class B { public void test() { System.out.println("B=>test()"); } } 重写：需要有继承关系，子类重写父类的方法！ 1.方法名必须相同 2.参数列表必须相同 3.修饰符：数值可以扩大但是不能缩小：public>Protected>Default>private 4.抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundExcetion--->Exception(大) 重写，子类的方法和父类的方法必须要一致，方法体不同为什么需要重写？ 1.父类的功能子类不一定需要或者不一定满足！ ALt+Insert： override；多态

动态编译：类型：可扩展性

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

多态存在的条件：

有继承关系

子类重写父类方法

父类引用指向子类对象

package com.OOP.Demo06; public class Person { public void run(){ System.out.println ("run" ); } } package com.OOP.Demo06; public class Student extends Person { @Override public void run() { System.out.println ("son"); } public void eat(){ System.out.println ("eat"); } } /*注意事项 1.多态是方法的多态 2父类和子类，有联系，类型转换异常！ ClassCastException 3.存在条件：继承关系需要重写，父类引用指向子类对象！ father f1=new Son（）；不能重写的方法 1.static 方法属于类，它不属于实例 2.final常量 3.private方法 */ package com.OOP.Demo06; public class Application { public static void main(String[] args) { //一个对象的实际类型是确定的 //new Student() //new Person() //可以指向的引用类型就不确定了;父类的引用指向子类 //Student 能调用的方法都是自己的或者父类的 Student s1 = new Student (); //Person 父类型，可以指向子类，但是不能调用子类独有的方法 Person s2= new Student (); Object s3= new Student (); //对象能执行那些方法，主要看对象左边的类型和右边关系不大 s2.run ();//子类重写了父类的方法，执行子类的方法 s1.run (); s1.eat (); //s2.eat();//不能用 } }

注意：多态是方法的多态，属性没有多态

instanceof（类型转换）引用类型，判断一个对象是什么类型。

package com.OOP.Demo06; public class Application { public static void main(String[] args) { //类型之间的转换：父子 //高 Person obj=new Student (); //student将这个对象转换为Student类型，我们就可以使用student类型的方法了 //子类转换为父类，可能丢失之间本来的一些方法 Student student = ( Student ) obj; student.go ( ); Person person=student; /* 1.父类引用指向子类的时候 2.把子类转换为父类，向上转型 3.把父类转换为子类，向下转型，强制转换 4.方便方法的调用，减少重复的代码 */ /* //Object>String //Object>Person>Teacher //Object>Person>Student Object object = new Student ( ); //System.out.println ( x instanceof Y); //能不能编译通过 System.out.println (object instanceof Student );//true System.out.println (object instanceof Person );//true System.out.println (object instanceof Object );//true System.out.println (object instanceof Teacher);//false System.out.println (object instanceof String );//false System.out.println ("============================" ); Person person= new Student (); System.out.println (person instanceof Student );//true System.out.println (person instanceof Person );//true System.out.println (person instanceof Object );//true System.out.println (person instanceof Teacher);//false // System.out.println (person instanceof String );//编译报错！ System.out.println ("============================" ); Student student=new Student (); System.out.println (student instanceof Student );//true System.out.println (student instanceof Person );//true System.out.println (student instanceof Object );//true //System.out.println (student instanceof Teacher);//编译报错 //System.out.println (student instanceof String );//编译报错 */ } } package com.OOP.Demo06; public class Person { public void run(){ System.out.println ("run"); } } package com.OOP.Demo06; public class Student extends Person { public void go(){ System.out.println ("go" ); } } package com.OOP.Demo06; public class Teacher extends Person { } static package com.OOP.Demo07; //static public class Student { private static int age;//静态的变量 private double score;//非静态的变量 public void run(){ go (); } public static void go(){ } public static void main(String[] args) { //run();//编译错误 } /*public static void main(String[] args) { Student s1 = new Student ( ); System.out.println (Student.age); System.out.println (s1.age); System.out.println (s1.score); } */ } package com.OOP.Demo07; public class Person { { //2:初始值 //代码块（匿名代码块） System.out.println ("匿名代码块" ); } //1:只执行一次 static { //非静态代码块 System.out.println ("静态代码块" ); } //3 public Person(){ System.out.println ("构造方法" ); } public static void main(String[] args) { Person person1 = new Person ( ); System.out.println ("==================" ); Person person2 = new Person ( ); } } package com.OOP.Demo07; //静态导入包 import static java.lang.Math.random; import static java.lang.Math.PI; public class Test { public static void main(String[] args) { System.out.println (random () ); System.out.println ( PI); } } 5.抽象类和接口抽象类

abstract修饰符

package com.OOP.Demo08; //abstract 抽象类：类，extends：单继承（接口可以多继承） public abstract class Action { //约束 //abstract 抽象方法，只有方法名字，没有方法实现 public abstract void doSomething(); //1.不能new这个抽象类只能靠子类去实现它：约束！ //2.抽象类中可以写普通方法 //3.抽象方法必须在抽象类中 //抽象的抽象：约束 } package com.OOP.Demo08; //抽象类的所有方法，继承了它的子类，都必须实现它的方法 public class A extends Action { @Override public void doSomething() { } } 接口

只有规范！

约束和实现分离

声明类的关键字是class，声明接口的关键字是interface

接口的本质是契约

package com.OOP.Demo09; //抽象的思维 // interface 定义的关键字,接口都需要是实现类 public interface UserService { //接口中的所有定义其实都是抽象的 public abstract //常量 publi static final int AGE=99; void add(String name); void delete(String name); void update(String name); void query(String name); } package com.OOP.Demo09; //抽象类：extens //类可以实现接口 implements 接口 //实现接口的类，就需要实现接口的方法 //多继承利用接口实现多继承 public class UserServiceImpl implements UserService,TimeService{ @Override public void add(String name) { } @Override public void delete(String name) { } @Override public void update(String name) { } @Override public void query(String name) { } @Override public void timer() { } } package com.OOP.Demo09; public interface TimeService { void timer(); } 作用： 1.约束 2.定义一些方法，让不同的人实现 3.public abstract 4.publi static final 5.接口不能被实例化，接口中没有构造方法 6.implements可以实现多个接口 7.必须重写接口中的方法 6.内部类及OOP实战成员内部类静态内部类局部内部类匿名内部类 package com.OOP.Demo10; public class Outer { private int id=10; public void out(){ System.out.println ( "这是外部类的方法"); } //局部内部类 public void method(){ class Inner{ public void in(){ } } } //一个java类中可以有多个class类，但是只能有一个public class /* class Inner{ public void in(){ System.out.println ("这是内部类的方法" ); } //获得外部类的私有属性 public void getID(){ System.out.println (id ); } } */ } package com.OOP.Demo10; public class Test { public static void main(String[] args) { //Apple apple = new Apple ( ); //没有名字去初始化类,不用将实例保持到变量中 new Apple ().eat (); //匿名内部类 UserService userService= new UserService ( ) { @Override public void hello() { } }; } } class Apple{ public void eat(){ System.out.println ("1" ); } } interface UserService{ void hello(); }

【本文地址】

公司简介

联系我们