java基础-小白入门（面向对象中）

最新推荐文章于 2024-07-16 18:55:21 发布

@赤

最新推荐文章于 2024-07-16 18:55:21 发布

阅读量205

点赞数 1

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java基础 java封装、继承、多态

本文链接：https://blog.youkuaiyun.com/weixin_42683028/article/details/91381903

java 专栏收录该内容

5 篇文章

订阅专栏

本文介绍了Java面向对象的三大特点：封装、继承和多态。封装是将类的属性和方法隐藏，通过公共方法访问；继承包括类的继承和接口的继承，子类可继承父类属性和方法；多态基于继承，有向上转型和向下转型，利于程序维护。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

面向对象的三大特点
封装、继承、多态

1.封装

何为封装？封装即为将类的属性和方法隐藏起来，不对外界展示内部结构，只提供公共的方法对其进行访问。
为了保证对象属性和行为的安全，保证类内部数据结构的完整性，用户只能通过公共的方法对对象的属性进行更改。需要进行封装的属性和方法必须用private修饰。

package encapsulate;

public class Class {
	private String name;
	private int age;
	private String sex;
	private String id;
	//设置get、set方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	//私有方法，在其他类中无法被调用
	private void sing() {
		System.out.println("hello world!");
	}

}

private是权限修饰符，被private修饰的属性和方法只能被本类访问，而无法被其他类访问。若想改变private修饰的属性的值，只能通过get、set方法来改变和访问。因此避免了信息的泄露、避免了他人非法修改属性的值。

package encapsulate;

public class Class1 {
	public static void main(String[] args) {
		Class cl=new Class();
		cl.setSex("Bin");
		System.out.println(cl.getSex());
	}
	

}

2.继承

2.1类的继承

java继承的基本思想是基于某个类，对其进行扩展，制定出一个新的类。原来的类成为父类或基类，扩展出来的新类称为子类。子类可以继承父类所有的属性和方法，也可以直接重写父类中的某些方法。
**注意：一个子类只能继承一个父类，但是一个父类可以有多个子类，但是接口允许多继承（注意接口和类的区别）

package 继承;

public class Student extends Humen {
	public static void main(String[] args) {
		Student stu=new Student();
		stu.age=20;
		stu.sex="男";
		stu.eat();
		stu.sleep();
	}
	public Student() {
		System.out.println("我是子类的构造方法");
	}

}

 class Humen{
	private boolean life;
	
	public  String sex;
	public  int age;
	
	public void eat() {
		System.out.println("我正在吃饭");
	}
	public void sleep() {
		System.out.println("我正在睡觉");
	}
	private void live() {
		System.out.println("我是活的");
	}
	public Humen() {
		System.out.println("我是父类的构造函数");
	}
	
	
	
}

上面的一段程序有一个关键字extends，表示继承。同时子类程序中没有声明任何属性和方法，但是子类对象却可以调用父类的所有属性和方法。（继承）
读者可以先来想一下输出结果是什么，接下来是输出结果：

程序流程：1.子类创建一个对象，调用子类构造函数，子类构造函数第一行隐式调用父类构造函数，然后执行子类构造函数中的语句。
2.子类对象调用从父类继承来的属性和方法。

2.2接口的继承

接口是一种特殊的抽象类，接口是不同类或者不同对象相同方法的集合，其属性均为常量，方法均为抽象方法（不可创建对象的原因）。话不多说，直接上代码：

package 接口的继承及其实现;

public interface Controler {
	final String id="遥控器";    //设置其编号
	final int boundrate=115200;  //设置通信时的波特率
	public boolean up_date();     //控制器更新的方法
	public boolean ok();     //控制器确认的方法
	public int add_chinal();   //控制器增加频道
	public int reduce_chinal();   //控制器减小频道

}

package 接口的继承及其实现;

public interface Controler2 {

}

package 接口的继承及其实现;

public interface Controler3 extends Controler,Controler2 {

}

package 接口的继承及其实现;

public class Television implements Controler,Controler2{
/*
*@Override表示重写
*
*/
	@Override
	public boolean up_date() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean ok() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public int add_chinal() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int reduce_chinal() {
		// TODO Auto-generated method stub
		return 0;
	}

}

上面四个代码片段，前三个都是接口，分别是Controler 、Controler2 、Controler3 ，最后一个是实现类Television 。上面的代码中有一个新的关键词implements，表示实现。一个接口可以继承多个接口；一个类可以实现多个接口，但必须重写所实现接口中的所有抽象方法，否则编译不通过。

3.多态

多态是指某个类在不同的情况下所展现出不同的类型，有利于程序的维护。多态的基础是继承。。。。。不行，上代码吧

package 多态;

public class PolyTest {
	public static void main(String[] args) {
		//向上转型
		People pe=new Student();
	    pe.age=20;
	    pe.height=175.2;
	    pe.nation="中国";
	    pe.sex="男";
	    pe.eat();
	    pe.run();
	    pe.sleep();
	    
	    
	    //向下转型
	    Student st=(Student) pe;
	    st.id="19980902";
	    st.study();
	 
	}

}

完整的代码将在文末给各位奉上，这里只讲解上面一段代码中的多态形式：
People pe=new Student(); 创建的类型与调用的构造函数不符（必须是创建父类对象，调用子类的构造函数，即“=”右边必须是左边的子类或者左边接口的实现类）这句话的意思是创建了一个People类实例pe,但是其引用对象为Student类型，也就是说pe实际上是一个Student类型的实例，这种创建对象的方法称为向上转型。
实例化的对象在编译阶段调用变量属性时，只会调用父类与子类共同拥有的属性，不会调用子类特有的属性，在运行阶段调用的也是父类的属性；
实例化的对象在编译阶段调用方法时，只会调用父类与子类共同拥有的方法，不会调用子类特有的方法，在运行阶段调用的是子类的方法。（注意与变量的区别）
简单的记法：变量编译运行都看左边，方法编译看左，运行看右。
上面代码的第二段，通过向下转型，可以将实例化的对象转换成子类对象，这时可以调用子类特有的变量和方法，而且运行时调用的也是子类的变量和方法。
上述源码