Java教程
二、Java面向对象特征
本文主要是介绍二、Java面向对象特征，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
Java SE复习总目录
本人情况说明：20年春学过Java语言，了解简单语法，但并不会应用，面向对象的特征及堆栈的概念也并不清楚，希望这个假期可以进行总体的回顾，并通过记博客的方式督促自己，巩固知识，欢迎有相同目标的小伙伴共同交流，一起进步鸭~~
文章目录
- 前言
- 一、类和对象
- 1.什么是类
- 2.局部变量与成员变量
- 3.什么是对象
- 4.方法参数与方法重载
- 二、封装
- 三、继承
- 1.继承的概念
- 2.方法重写
- 四、多态
前言
Java面向对象的三大基本特征(封装、继承、多态)：本章主要对这三大特征进行简要介绍。
一、类和对象
1.什么是类
1. 类包含两部分:
数据→属性/成员变量
对数据的操作→方法。
2. 方法定义不能嵌套；方法只能定义在类中。
3. 使用new通过类生成对象。
public class Text {
public static void main(String[] args) {
Person person=new Person();//生成对象，必须在main方法里
}
}
class Person
{
//类的属性和方法
}
4. return；表示什么也不返回，当程序运行到该语句时，退出该方法，即不再执行该语句后面的语句。5. 类与方法的命名: 类名中的每个单词首字母大写，如MemberTest。
方法名首个单词全小写，以后每个单词首字母大写，如addThreeInt 属性名与方法名相同，例age，ageOfPerson。
2.局部变量与成员变量
6. 定义在类里的变量叫成员变量，定义在方法里的变量叫局部变量。
7. 使用.来使用类的属性。
8. 局部变量使用前必须要声明并赋初值，成员变量使用前必须要声明，可以不赋初值（有默认初始值:byte,int short long为0，float,double为0.0，char为'\u0000'，boolean为false）。
public class Text {
int a;//成员变量，可以不赋初值
public void method()
{
int b = 0;//定义在方法里，是局部变量，必须赋初值
System.out.println(b);
}
public static void main(String[] args) {
Text text=new Text();//main方法需先生成对象，再进行对类的操作
System.out.println(text.a);
text.method();
}
}
3.什么是对象
9. Java中无法直接操纵对象，都是通过引用来对对象进行操作， Peaple people = new people()；中people为引用，new people ()为对象，对象在堆中，而引用在栈中，多个引用可指向一个对象，通过一个引用改变对象，其他引用也随之改变。
10. 类中的每一个对象有各自的属性，但共享一个方法。
public class Text {
int a;
public void method()
{
int b = 0;
System.out.println(b);
}
public static void main(String[] args) {
Text text1=new Text();
Text text2=new Text();
text1.a=1;//对象1有其自己的成员变量a=1
text2.a=2;//对象2有其自己的成员变量a=2
System.out.println(text1.a);
System.out.println(text2.a);
text1.method();
text2.method();//对象1和对象2共用一个方法method，均输出0
}
}
1 2 0 011. 引用的类型和对象的类型相同。
Text t=new Text();//t是引用，不是对象，new Text()生成一个对象12. new关键字生成对象时:为对象开辟内存空间→调用类的构造方法→将生成的对象的地址返回。
13. 将一个引用赋值给另一个引用相当于创建了一个指向该对象的新引用，即此时有两个引用指向同一对象；而几个new就表示有几个对象，new对应的引用指向各自不同的对象。
public class Text {
public static void main(String[] args) {
Person person1 = new Person();
System.out.println(person1.age);//输出20
Person person2 =person1;//person2和person1指向同一个对象，一个改变也影响另一个。
person2.change(person2);
System.out.println(person1.age);//输出18
System.out.println(person2.age);//输出18
}
}
class Person
{
int age = 20;
public void change(Person person1)
{
age=18;
}
}
20 18 18
public class Text {
public static void main(String[] args) {
Person person1 = new Person();
System.out.println(person1.age);//输出20
Person person3 = new Person();//person3和person1指向不同对象，一个改变不影响另一个。
person3.change(person3);
System.out.println(person1.age);//输出20
System.out.println(person3.age);//输出18
}
}
class Person
{
int age = 20;
public void change(Person person1)
{
age=18;
}
}
20 20 18
4.方法参数与方法重载
14. 构造方法用于完成对象属性的初始化工作，其名字与类名相同，且无返回值（即访问修饰符直接跟方法名，void表示返回空，也算作有返回值），若类中未定义，则默认隐式定义一个方法体为空的构造方法。class A
{
public A()
{
//可手动编写，默认为空
}
}
class A //未定义构造方法的类，默认为空，同上，不可见
{
}
15. 调用构造方法传递参数，形参表示又创建了一个指向该对象的新引用。以上面的代码为例，此时有
public class Text
{
public static void main(String[] args) {
Person zhangsan = new Person();
zhangsan.change();
System.out.println("----------------------");
zhangsan.change(20);
}
}
class Person
{
public void change(){
}
public int change(int age){
System.out.println(age);
return age;
}
}
---------------------- 2017. 构造方法的重载:只需看参数即可，若想在一个构造方法中调用另一个构造方法，使用this()，他必须作为该构造方法的第一条语句。
public class Text
{
public static void main(String[] args)
{
Person zhangsan = new Person();
Person lisi = new Person(20);
}
}
class Person
{
public Person()
{
System.out.println("无参构造");
}
public Person(int age)
{
System.out.println("有参构造");
}
}
无参构造 有参构造
public class Text
{
public static void main(String[] args)
{
Person zhangsan = new Person();
}
}
class Person
{
public Person()
{
this(20);
System.out.println();//一个构造方法使用this调用重载的另一个构造方法，注意this语句要放在第一位
}
public Person(int age)
{
System.out.println("年龄为"+age);
}
}
年龄为20
二、封装
18. 封装的概念：利用访问权限修饰符将某个类的代码和数据包装、隐藏起来，作为一个保护屏障防止被修改。19. 访问控制修饰符：
私有的——private(封装部分多用其来修饰)
默认的——不使用任何修饰符
受保护的——protected
公开的——public
三、继承
1.继承的概念
20. Java是单继承，即一个类只有一个父类，执行时先执行父类的构造方法（不带参数），生成父类的对象，再执行子类的构造方法（不带参数），再生成子类的对象；若父类无不带参数的构造方法，须在子类中使用super(参数)来调用，若有，使用super就会去调用带参数的，而忽略不带参数的，super与this一样，也必须作为构造方法的第一条语句。public class Text
{
public static void main(String[] args)
{
Rose rose = new Rose();
}
}
class Flower
{
public Flower(){
System.out.println("这里有一朵花");
}
}
class Rose extends Flower
{
public Rose(){
System.out.println("这里有一朵玫瑰花");
}
}
这里有一朵花 这里有一朵玫瑰花
public class Text
{
public static void main(String[] args)
{
Rose rose = new Rose();
}
}
class Flower
{
public Flower(){
System.out.println("这里有一朵花");
}
public Flower(int size){
System.out.println("这里有一朵直径为5cm的花");
}
}
class Rose extends Flower
{
public Rose(){
super(5);
System.out.println("这里有一朵玫瑰花");
}
}
这里有一朵直径为5cm的花 这里有一朵玫瑰花21. 方法和属性可以被继承，构造方法不能被继承(子类仅仅执行但并不继承，它有自己的构造方法)。
2.方法重写
22. 方法重写（@Override）用于继承，子类和父类的方法类型名称，参数都相同。23. super.重写的方法名()可以同时调用子类和父类的重写方法，此时super语句不一定要放在第一行。
public class Text
{
public static void main(String[] args)
{
Rose rose = new Rose();
rose.size();
}
}
class Flower
{
public void size(){
System.out.println(6);
}
}
class Rose extends Flower
{
public void size(){
super.size();
System.out.println(4);
}
}
6 424. 注意区分方法重载和方法重写，重载指类中同名的两方法，根据参数的不同，编译器自动进行调用；重载是子类对父类方法的改写。
四、多态
25. 多态是指:父类型的引用可以指向子类的对象，例 Flower rose=new rose();26. 多态中调用的方法必须同时在父类和子类中出现。
27. 多态中父类型的引用可强制转换成子类型。
Flower rose1 = new Rose(); Rose rose = (Rose) rose1;28. 多态的应用:同一父类下的多个子类实现一个功能时，只用父类中的一个方法即可完成，注意该方法的参数为父类。
class Car
{
public void run (Car car)
{
car.run();
}
}
//之后可定义多种类表示各种具体汽车，再在这些类下实现（重写）各车独有的run方法
这篇关于二、Java面向对象特征的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
HarmonyOS NEXT开发实战：打造高效上拉刷新与下拉加载组件（一）空页面的设计与实现11-17
-
职场毒瘤：无脑尊蠢老！我不反对尊老，我只是反对没有脑子的尊老！11-17
-
顶级企业如何用数据脱敏保护用户隐私！11-17
-
ShardingSphere 如何完美驾驭分布式事务与 XA 协议？11-16
-
ShardingSphere如何轻松驾驭Seata柔性分布式事务？11-16
-
Maven资料入门指南11-16
-
Maven资料入门教程11-16
-
MyBatis Plus资料：新手入门教程与实践指南11-16
-
MyBatis-Plus资料入门教程：快速上手指南11-16
-
Mybatis资料入门教程：新手必看指南11-16
-
MyBatis资料详解：新手入门与初级实战指南11-16
-
MyBatisPlus资料：初学者入门指南与实用教程11-16
-
MybatisPlus资料详解：初学者入门指南11-16
-
MyBatisX资料：新手入门与初级教程11-16
-
RESTful接口资料详解：新手入门指南11-16
栏目导航
