Java中面向对象

最新推荐文章于 2024-07-30 20:50:32 发布

jianda-jm

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量44

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_43126636/article/details/116003501

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

这里是引用

Java的核心思想OOP

oop是面向对象

一、初始面向对象

1.面向过程&面向对象

面向过程思想

步骤清晰简单，做具体的事情

面向对象

已分类的思想对需要解决的问题进行分类，然后对分类的问题单独进行思考。

总结

对于复杂的事务，为了从整体把握，需要使用面向对象来分析，具体到实际的操作需要面向过程。面向过程与面向对象不可分割。

2.面向对象

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。

2.1类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。
对象是类的实例化，是具体的，例如人民群众是类，张三就是其中一个具体的对象，是一个人民，他的特征有属性表示，活动有方法表示。

二、方法的回顾与加深

1.程序从main方法开始执行

1.1所有方法都在类中定义。
方法定义
修饰符返回值类型方法名（…）{
方法体
return 返回值；
}

2.返回值类型

return 代表所在的方法结束；必须还返回值类型相同;当类型为void时 return 不写或只有return；
命名规则：驼峰命名

3.方法的类型

静态方法
public static void main（）
是和类一起加载的

非静态方法
public static void main
（1）实例化这个类 new
对象类型对象名 = 对象值；
（2）在实例化后才能被调用

4.方法的调用

静态的方法可以直接调用，非静态的方法不可以直接调用。
静态的方法可以调用静态的方法；非静态的方法也可以调用非静态的方法，但是静态的方法不可以调用非静态的方法。

5.形式参数与实际参数

实际参数要与形式参数的类型一致

调用方法进行传参时,分为值传递和引用传递两种。

如果参数的类型是基本数据类型,那么就是值传递。
如果参数的类型是引用数据类型,那么就是引用传递。

值传递是实参把自己变量本身存的简单数值赋值给形参。

引用传递是实参把自己变量本身存的对象内存地址值赋值给形参.
所以值传递和引用传递本质上是一回事,只不过传递的东西的意义不同而已。（目前不懂 2021.4.22）。
值传递代码如下（示例）：

public class vlaueTrans {
		public void static main(String[] args){
		int a = 1;
		System.out.println(a);   // a = 1
		valueTrans.change(a);
		System.out.println(a);  // a = 1 ,a的值并未改变
		} 
public static void change(int a)
		a = 10;
}

引用传递代码如下（示例）：

public class Demo03 { 
	public static void main(String[] args){ 
		Student s = new Student(); 
		System.out.println("before: name = "+s.name); //null 
		changeName(s); 
		System.out.println("after: name = "+s.name); //tom 
		} 
	public static void changeName(Student s){ 
		s.name = "tom"; //此时已经将值传递给了Student类中的name属性
		}
	}
	class Student{ 
	String name;
	}

6.判断方法是否一致

1.方法名称相同
2参数列表

三、对象的创建与分析

1.使用new创建对象使用new关键字创建对象

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

类是对象的模板，是对对象的抽象，对象是类的实例化。

2.构造器(无参构造与有参构造)

2.1使用new关键字，必须要有构造器
构造器：
1.和类名相同
2.没有返回值
作用：
1.new本质在调用方法
2.初始化对象的值
注意点：
1.定义有参构造后，如果想使用无参构造，显示的定义
一个无参的构造，无参必须显示。
Alt + Insert （构造无参
）
this. 表示当前类

3.对象内存分析

代码如下（示例）：

public class Application{
	public static void main(String[] args){
  		Pet dog = new Pet();
  		dog.name = "旺财"；
  		dog.age = 3;
  	}
}
public class Pet{
	//无参构造
	public Pet(){
		 public String name；
		public int age；
	}
	public void shout(){
		System.out.println("叫了一声")；
	}
}

alt

四、面向对象的三大特性

1.封装

1.1封装的含义

设计程序要求““高内聚”，”低耦合“”。内部的数据操作细节自己完成，外部仅有少量的方法。

避免直接访问数据，通过接口访问。

封装：数据的隐藏
属性私有，get/set

public class Student{
	// 私有 prviate 
	private String name;
	private int id;
	private char sex; 
}

使用公共的方法 get/set获得数据
ALT+Insert 创造get和set。

1.2封装的意义：

1.提高了程序的安全性，保护数据。

2.隐藏代码的实现细节

3.统一接口

4.系统的可维护性增加了

2.继承

2.1继承的本质

1.继承的本质是对某一批类的抽象。从而对世界更好的建模。

2.extends的意思是”扩展“。子类是父类的扩展。

3.JAVA中只有单继承，没有多继承！一个儿子只有一个爸爸，一个爸爸可以有多个儿子。

4.继承是类和类之间的关系，除此之外其他的关系还有依赖，组合，聚合等。
5.子类继承父类使用关键字extends表示。

  //preson 人 ： 父类
  public class Person{
  	
  
  }
  public class Student extends Person{   ：子类 派生类

}
public class Teacher extends Person{

}

3.Object类

java中所有的类都直接或间接继承Object。

4.super

super和this
super代表父类，this代表当前类

私有的东西无法被继承

1.super注意点：
（1）super调用父类的构造方法，必须在构造方法第一个
（2）super必须只能出现在子类的方法构造方法中！
（3）super和this不能同时调用构造方法！
2.this和super的不同

（1）代表的对象不同
this ：本身调用者这个对象
super：代表父类对象应用

（2）前提：
this：没有继承也可以使用
super：只能在继承中使用

（3）构方法：
this（）：本类的构造
super（）：父类的构造

5.方法的重写

重写：需要有继承的关系，子类重写父类的方法！
1.方法名称必须相同
·
2.参数列表必须相同

3修饰符：范围可以扩大但不能缩小： public>protected>default>private

4.抛出异常：范围，可以被缩小，但不能被扩大： ClassNotFoundException–>Exception(大)
重写，子类的方法和父类的方法必须要一致：方法体不同！
父类的非静态方法不能被子类重写为静态方法；

为什么要重写：
1.父类的功能，子类不一定需要，或不一定满足！
静态方法不能重写代码如下（示例）：

package com.opp.demo03;

public class Application {
    public static void main(String[] args) {
    //静态static方法的调用只和左边，定义的数据类型有关
        A a = new B();
        a.print();

//父类引用指向了子类
        B b = new B();
        b.print();
    }
}
package com.opp.demo03;

public class B extends A {

    public static void print() {
        System.out.println("b-next");
    }
}
package com.opp.demo03;

public class A {
    public static void print(){
        System.out.println("a-next");
    }
}

非静态方法代码如下（示例）：`

package com.opp.demo04;

public class Application {
    public static void main(String[] args) {
        A a =new A();
        a.test();
//非静态方法重写
        //父类的引用指向了子类
        B b =new A();
        b.test();//B

    }

}
package com.opp.demo04;

public class A extends B{
    //重写
    @Override//注解：有功能的注释！
    public void test() {
        System.out.println("这是子类");
    }
}
package com.opp.demo04;
//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("这是父类");
    }
}
//这是子类
//这是子类

6.多态

1.多态的含义

（1）即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
（2）一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）

2 多态存在的条件

有继承的关系
子类重写父类的方法
父类引用子类的对象

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
         //Student s3 = new Person();这样的，这不合法的，没有父哪来的孩子
        s1.run();
        s2.runs();//方法名不同，只和对象左边的类型有关

        s1.eat();//方法名相同，方法重写父类的方法，执行子类的方法
        s2.eat();

        //父类可以指向子类，但是不能调用子类独有的方法
        //s2.see();
        s1.see();
package com.opp.demo05;

public class Student extends Person {
    public void run(){
        System.out.println("子类跑起来了");
    }
    public void eat(){
        System.out.println("子类吃");
    }
    public void see(){
        System.out.println("子类看");
    }
}
package com.opp.demo05;

public class Person {
    public void runs(){
        System.out.println("父类跑起来了");
    }
    public void eat(){
        System.out.println("父类吃");
    }
}

多态注意事项：
1. 多态是方法的多态，属性没有多态性。
2.父类和子类，有联系类型转化异常ClassCastException！
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！
Father f1 = new Son（）；
4.不能重写的方法：
（1）static方法
（2）final常量
（3）private 私有的

现实中，比如我们按下 F1 键这个动作：
如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果
6.instanceof 判断有没有继承关系
A instanceof B
该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有"子父类关"系就编译通过, 没有子父类关系就是编译报错.

public class Person{ 
		public void run(){} 
}
		
		public class Student extends Person{ 
}
		
		public class Teacher extends Person{
}
main: 
Object o = new Student(); 
System.out.println(o instanceof Student);//true    判断o与student和object是不是有继承关系
System.out.println(o instanceof Person);//true 
System.out.println(o instanceof Object);//true 
System.out.println(o instanceof Teacher);//false teacher虽然与object有关但是和student无关
System.out.println(o instanceof String);//false

Person o = new Student(); 
System.out.println(o instanceof Student);//true 
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
 System.out.println(o instanceof Teacher);//false teacher虽然与person有关但是和student无关
 //编译报错 System.out.println(o instanceof String);



Student o = new Student(); 
System.out.println(o instanceof Student);//true 
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true 
//编译报错 System.out.println(o instanceof Teacher); 
//编译报错 System.out.println(o instanceof String);

7.总结

父类引用可以指向子类对象，子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。
如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）
father；
其中father前面的（Son）必须添加，进行强制转换。
4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效
5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样
使代码变得简洁。体现了JAVA的抽象编程思想。

8.static关键字详解

静态变量对于类，所有对象（实例）所共享，当直接使用类去调用得到说明这个变量是静态

//static
public class student{
	private static int age;  //静态变量
	private double score；//非静态变量

pubic static void main （String[] args）{
	Student s1 = new Student();
	System.out.println(Student.age);
	
}
}

9静态代码块和匿名代码块

public class Person{
 			{
					匿名代码块
				}
				static{
				 			静态代码块
							
					}
	public Person（）				
				
}

静态代码块先执行，但执行一次
匿名代码块第二个执行
构造方法最后执行

五、抽象类接口

1.抽象类

//abstract 抽象类 ：类 extends  单继承      （接口可以多继承）类似于插座
public abstract class Action {

    //约束 有人帮我们实现方法
    //abstract,抽象方法，只有名字，没有方法实现！
    //有构造器
    public abstract void something();

    //  1.不能new出来，只能靠子类其实现它 是一种约束
    // 2.抽象类可以写抽象方法
    //3.抽象方法只能在抽象类中
}

2.接口

接口只有规范！自己无法写方法，专业的约束！约束和实现分离：面向接口编程~

接口的本质是契约，就像法律一样，制定好大家都遵守

学完java之后看设计模式

声名接口的关键字是interface

interface 接口都需要实现类；

方法，接口中的所有定义的方法其实都是抽象的

接口中所有属性都是常量
类可以实现接口， implements
实现接口的类，就需要重写接口中的方法~
多继承~ 利用接口实现多继承~

package com.opp.demo08;

//类可以实现接口， implements
//实现接口的类，就需要重写接口中的方法~
// 多继承~ 利用接口实现多继承~

public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void run() {

    }

    @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() {

    }
}

2.1总结

作用：
1.约束
2.定一些方法，以不同的方式实现
3.public abstract
4.public static final
5.接口不能被实例化，接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法
8.总结博客

jianda-jm

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中面向对象

Java的核心思想OOP oop是面向对象文章目录Java的核心思想OOP一、初始面向对象1.面向过程&面向对象2.面向对象二、方法的回顾与加深1.程序从main方法开始执行2.返回值类型3.方法的类型4.方法的调用5.形式参数与实际参数三、对象的创建与分析1.使用new创建对象使用new关键字创建对象2.构造器(无参构造与有参构造)3.对象内存分析四、面向对象的三大特性五、抽象类接口六、内部类及OPP实战一、初始面向对象1.面向过程&面向
复制链接

扫一扫