面向对象：封装，继承，多态，抽象类，接口，内部类

最新推荐文章于 2023-03-01 21:53:08 发布

queenliuy

最新推荐文章于 2023-03-01 21:53:08 发布

阅读量113

点赞数

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

本文链接：https://blog.csdn.net/weixin_44695332/article/details/112689014

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

***封装：***属性私有 get()/set()

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加

//学生类

public class Student {
	//属性：字段
	 private  String name;//null
	 private int age;//0
	 private int id;
	 private char sex;
	 
	 
	//提供一些可以操作这个属性的方法
	 //提供一些public的get/set方法
	 
	 
	
	public String getName() {
		return name;
	}
	//set()方法可以写入逻辑代码
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	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 class Demo01 {
	public static void main(String[] args) {
		//实例化类
		//类实例化后，会返回一个自己的对象
		//Student对象就是一个Student类的具体实例
		Student xiaoming =new Student();
		//Student xiaozhang =new Student();
		
		xiaoming.setName("小明");
		System.out.println(xiaoming.getName());
		}
	}

继承：本质:类的抽象 extends。子类是父类的扩展
类与类的一种关系

//父类
public class Person {

}
//派生类，子类
`public class student extends Person{

}``
子类继承父类，就会拥有父类的全部方法  （public）

```java
public class Person {
	public void say() {
		System.out.println("说话了");
	}
}
public class student extends Person{
	
}
public class Application {
	public static void main(String[] args) {
		student s=new student();
		s.say();//可调用父类方法
	}
}

在Java中默认直接或间接继承Object类
Java中类的继承是单继承，一个儿子只能有一个爸爸，爸爸可有多个儿子
在这里插入图片描述
super/this
super:调取父类属性
this:调取该类属性
super注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
supre和this不能同时调用构造方法

VS this
代表对象不同：this：本身调用这个对象 super：代表父类对象的应用
前提：this:没有继承也可以使用 super：只能在继承条件下才能使用
构造方法不同： this（）：本类的构造 super（）：父类的构造

public class Person {//保护
		protected String name="刘阳";
	}
public class student extends Person{
	private String name="小刘";
	public void test(String name) {
		System.out.println(name);//方法属性
		System.out.println(this.name);//类属性
		System.out.println(super.name);//父类属性
		
	}
}
public class Application {
	public static void main(String[] args) {
		student s=new student();
		s.test("刘渣渣");
		
	}
}

结果：
在这里插入图片描述
方法重写：需要有继承关系，子类重写父类的方法

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，不可缩小
抛出异常：范围可以被缩小，不可扩大

重写：子类的方法和父类必须相同，方法体不同

为什么要重写?

父类的功能：子类不一定需要，或者不一定满足

静态

public class B {
	public static void test() {
			
			System.out.println("Btest");
	}
}
//重写是方法的重写，与方法无关
public class A extends B {
	public static void test() {
		
		System.out.println("Atest");
	}
	
}
public class Application {
	public static void main(String[] args) {
		//方法的调用只和左边的类型有关，与定义数据类型无关
		A a=new A();
		a.test();//A类
		//父类的引用指向了子类
		B b=new A();
		b.test();//B
	}
}

结果：
在这里插入图片描述
非静态重写：

public class B {
	public void test() {
			
			System.out.println("Btest");
	}
}
//重写是方法的重写，与方法无关
public class A extends B {
		//Override 重写
	@Override//注解：有功能的注释
	public void test() {
		
		System.out.println("atest");

	
}
//静态方法和非静态方法区别很大。非静态为重写，子类重写父类

public class Application {
	public static void main(String[] args) {
		//方法的调用只和左边的类型有关，与定义数据类型无关
		A a=new A();
		a.test();//A类
		//父类的引用指向了子类
		B b=new A();
		b.test();//B
	}
}

结果：
在这里插入图片描述

多态：方法的多态，属性没有多态
父类和子类有联系
存在的条件：继承，重写，父类引用指向子类Person s2=new student();22

	public class Person {
		public void run() {
			System.out.println("run");
		}
	}
	public class student extends Person{

	@Override//快捷键  Alt+Q
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("son");
	}
	public void eat() {
		System.out.println("eat");
	}
	
		
	
}

public class Application {
	public static void main(String[] args) {
		//一个对象的实际类型是确定的，
		 //new student();
		 //new Person();
		
		//可以指向的引用类型就不确定了:父类的引用指向子类
		student s1=new student();//子类 能调用的方法是自己的或是继承父类的
		Person s2=new student();//父类  可以指向子类，不能调用子类独有的方法
		Object s3=new student();
		s2.run();//子类重写父类的方法，执行子类的方法   输出结果：son
		s1.run();//输出结果：son
		
		s1.eat();
	}
	
	
}

关键字：instanceOf 和类型转换
instanceOf ：判断两个类是否有父子关系

//前提：student，Teacher类都继承与Person类
public class Application {
	public static void main(String[] args) {
		//Object-》Person-》student
		//Object-》Person-》Teacher
		//Object-》String
		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(person instanceof String);//编译错误
		
	}
	
	
}

类型转化：

//前提：student，Teacher类都继承与Person类
public class Application {
	public static void main(String[] args) {
		//类型之间的转化  高低  高-》低：强转
		
		Person person =new student();
		//将person这个对象转化为student类型，就可以使用student类型的方法了
		student student=(student) person;
		student.go();
		//子类转化为父类，可能会丢失自己的本来的一些方法
		Person p=student;
	}
	
	
}

static

public class Person {
	public static void main(String[] args) {
		Person person =new Person();
		System.out.println("===========");
		Person person1 =new Person();
	}
	//2  赋初始值
	{
		
		System.out.println("匿名代码块");
	}
	//执行顺序：1  只执行一次
	static {
		
		System.out.println("静态代码块");
	}
	//3
	public Person(){
		System.out.println("构造方法");

	}

}

静态导入包

//静态导入包
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);
	}
}

抽象类：

//abstract抽象类  extends：单继承（接口可多继承）
public abstract class Action {
	public static void main(String[] args) {
		
	}
	//约束  有人帮我们实现  abstract：抽象方法，只有方法名字，没有方法的实现
	public abstract void doing() ;
	//抽象类特点：1.不能new抽象类，只能靠子类去实现它：约束
	//抽象类里可写普通方法，抽象方法必须写在抽象类中（抽象的抽象  约束）
	
}
//抽象类的所有方法。继承了它的子类，都必须要实现他的方法。除非类也抽象
public class A extends Action {

	@Override
	public void doing() {
		// TODO Auto-generated method stub
		
	}

	
	
}

接口
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法面向接口编程本质是契约
声明类的关键字是class，而声明接口的关键字是sinterface

//关键字：interface  接口都需要有实现类
public interface UserSerive {
	//常量  public static final
	int age=99;
	 void run(String name);//接口中所有定义其实都是抽象的 static
	 void  add(String name);
	 void delect(String name );
	 void update(String name);
	 void query(String  name);
	 
}
public interface TimeSerive {
	void time();
}

//接口的实现类   
//类可以实现接口，implement 接口 
//实现了接口的类，就需要重写接口里的方法
//多继承 利用接口实现多继承
public class UserSevriceImp1  implements UserSerive, TimeSerive{

	@Override
	public void run(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void add(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void delect(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void update(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void query(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void time() {
		// TODO Auto-generated method stub
		
	}
	
}

接口的作用：约束；定义一些方法，让不同的人实现；常量 public static final；可以实现多个接口，必须要重写接口中的方法；接口不能实例化，接口中没有构造方法

内部类
成员内部类
静态内部类
局部内部类
匿名内部类

public class Outer {
	private int id=10;
	public void out() {
		System.out.println("外部类方法");
	}
	
	public class Inter {
		public void in() {
			
			System.out.println("内部类方法");
		}
		//获得外部类的私有属性
		public void getID() {
			
			System.out.println(id);
		}
	}
}
public class Application {
	public static void main(String[] args) {
		Outer out=new Outer();
		//通过外部类来实例化内部类
		 Outer.Inter iner=out.new Inter();
		 iner.in();
		 iner.getID();
	}
}




public class Outer {
	
}
//一个Java类中可以有多个class类，但只能有一个public class类
class A{
	public static void main(String[] args) {
		
	}
	
}



public class Outer {
	//局部内部类
	public void mentod() {
		
		class Inner{
			
			
		}
	}
}



public class Test {
	public static void main(String[] args) {
		new Apple().eat();//没有名字初始化，不用将实例保存在变量中
	
		UserSerive uers=new UserSerive() {

			

			@Override
			public void run(String name) {
				// TODO Auto-generated method stub
				
			}
		}
	}

			
}	
			
		
		
		
	
class Apple{
	
	public void eat() {
		System.out.println("1");
	}
}
interface UersSerive{
	void eat();
}

queenliuy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象：封装，继承，多态，抽象类，接口，内部类

***封装：***属性私有 get()/set()提高程序的安全性，保护数据隐藏代码的实现细节统一接口系统可维护性增加//学生类public class Student { //属性：字段 private String name;//null private int age;//0 private int id; private char sex; //提供一些可以操作这个属性的方法 //提供一些public的get/set方法 publ
复制链接

扫一扫