JAVA:面向对象++封装+继承【详细】

一、创建对象

创建类和对象为num_1:

package mian;
//类为num_1
public class num_1 {
	int x=10;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_1 myObj = new num_1();
	    System.out.println(myObj.x);
	}

}
1
2
3
4
5
6
7
8
9
10
11

演示：

二、对象的属性

X在以上中是变量，它实际上是类的一个 属性。或者可以说类属性是类中的变量。
例如：创建一个名为 " num_2" 的类，具有两个属性：x和y：

public class num_2 {
	int x=1;
	int y=2;
	public sta
	}
1
2
3
4
5

2.1访问属性

可以通过创建类的对象并使用点语法 ( .) 来访问属性。示例将创建一个num_2的类，对象为num_2,并打印对象的y属性：

package mian;

public class num_2 {
	int x=1;
	int y=2;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		num_2 s=new num_2();//创建对象
		System.out.println(s.y);
		
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

演示：

2.2修改属性

修改属性x的值为10：

package mian;

public class num_3 {
	int x; //创建属性
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_3 s=new num_3();//创建对象
		s.x=10;//修改属性值为10
		System.out.println(s.x);//打印修改后的属性值
	}
}
1
2
3
4
5
6
7
8
9
10
11

也可以直接覆盖：

package mian;

public class num_3 {
	int x=5; //创建属性
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_3 s=new num_3();//创建对象
		s.x=10;//修改属性值为10
		System.out.println(s.x);//打印修改后的属性值
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13

如果不想覆盖现有值，将属性声明为final：

package mian;

public class num_4 {
	final int x=5; //创建属性
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_4 s=new num_4();//创建对象
		s.x=10;//修改属性值为10
		System.out.println(s.x);//打印修改后的属性值
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13

这样，如果再想要覆盖就会发生报错了。

三、方法（函数）

3.1什么是方法？

方法就是类似函数（不过在java中不叫函数，叫做方法），为什么要使用方法？重用代码：定义一次代码，多次使用。（就是其它语言的函数）。方法必须在类中声明。它是用方法的名称定义的，后跟括号()。Java 提供了一些预定义的方法，例如System.out.println()，但您也可以创建自己的方法来执行某些操作：
创建一个方法test：

public class num_5 {
	static void test() {
		System.out.println("川川菜鸟");
	}
1
2
3
4

调用定义的方法：

package mian;

public class num_5 {
	static void test() {
		System.out.println("川川菜鸟");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		test();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13

一个方法也可以多次被调用（可见方便性）：

package mian;

public class num_5 {
	static void test() {
		System.out.println("川川菜鸟");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		test();
		test();
		test();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.2方法单个参数

例如传入字符串：

package mian;

public class num_6 {
static void test(String name) {
	System.out.println("名字为："+name);
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		test("张三");
		test("李四");
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出为：

名字为：张三
名字为：李四
1
2

同理也可以数字参数：

package mian;

public class num_7 {
static void test(int num) {
	System.out.println("数字为："+num);
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		test(2);
		test(3);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出为：

数字为：2
数字为：3
1
2

3.3方法多个参数

例如传入字符和整形：

package mian;

public class num_8 {
static void test(String name,int age) {
	System.out.println(name+"年龄为："+age);
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		test("张三",22);
		test("李四",20);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

输出为：

张三年龄为：22
李四年龄为：20
1
2

3.4return使用

void关键字表示该方法不应返回值。如果希望方法返回值，可以使用原始数据类型（如int、 char等）代替void，并return 在方法内部使用关键字。例如：

package mian;

public class num_9 {
static int test(int n) {
	return n;
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println((2));
	}

}
1
2
3
4
5
6
7
8
9
10
11
12

也可以传入多个值，例如求两数和：

package mian;

public class num_10 {
static int test(int n,int m) {
	return m+n;
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(test(2,5));
	}
}
1
2
3
4
5
6
7
8
9
10
11

3.5方法中添加if

例如成年与否的判断：

package mian;

public class num_11 {
	static void checkAge(int age) {

	    if (age < 18) {
	      System.out.println("不幸的是，你未成年!");

	    } else {
	      System.out.println("恭喜成年！");
	    }
	}
	public static void main(String[] args) {
		checkAge(5);
		checkAge(20);

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

演示：

3.6方法重载

使用方法重载，多个方法可以具有相同的名称和不同的参数，例如：

int myMethod(int x)
float myMethod(float x)
double myMethod(double x, double y)
1
2
3

完整例子如下，两种方法可以添加不同类型的数字：

package mian;

public class num_12 {
	static int sum(int x, int y) {
		  return x + y;
		}

		static double sum(double x, double y) {
		  return x + y;
		}

		public static void main(String[] args) {
		  int num1 =sum(2, 3);
		  double num2 = sum(3.14, 2.15);
		  System.out.println("int: " + num1);
		  System.out.println("double: " +num2);
		}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

四、类的方法

定义一个方法，用以打印为本：

package mian;

public class num_13 {
//定义方法
static void test(){
	 System.out.println("川川帅哥");
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		test();//调用方法
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.1静态与非静态

经常会看到具有static或public 属性和方法的 Java 程序。static方法可以直接被调用，而public只能访问对象：

package mian;

public class num_14
{
		  // Static方法
		  static void StaticMethod()
		  {
		    System.out.println("static方法");
		  }`static方法
public方法
`
		  // Public 方法
		  public void PublicMethod() 
		  {
		    System.out.println("public方法");
		  }
		  // Main方法
		  public static void main(String[] args) 
		  {
		    StaticMethod(); //调用静态方法
		    num_14 my = new num_14();// 创建Main对象
		    my.PublicMethod(); //调用非静态punlic方法
		  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

执行为：

static方法
public方法

1
2
3

4.2使用对象访问方法

例如：创建类num_15 ，方法pr打印，tro方法自我结束， me对象。使用对象方法两个public方法。

package mian;

public class num_15 
{
	
	//打印方法
	public void pr()
	{
	    System.out.println("你好啊，世界！");
	}

	  // 速度这个方法
	  public void tro(String name)
	  {
	    System.out.println("我的名字叫做: " +name);
	  }

	  // 在main方法中，用main对象调用以上定义的方法
	  public static void main(String[] args)
	  
	  {
		  num_15  me = new  num_15 ();   // 创建对象
	    me.pr();      // 调用对象
	    me.tro("张三");     
	  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

执行：

你好啊，世界！
我的名字叫做: 张三
1
2

4.3多个类之间的调用

我们在一个类中创建方法，另一个类来调用。

num_16.java:

package mian;

public class num_16 {

	public void pr()
	{
	    System.out.println("你好啊，世界！");
	}

	  // 速度这个方法
	  public void tro(String name)
	  {
	    System.out.println("我的名字叫做: " +name);
	  }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

创建num_17.java:

package mian;

public class num_17 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_16 me = new num_16();
		me.pr();
		me.tro("川川");
	}

}
1
2
3
4
5
6
7
8
9
10
11
12

执行：

你好啊，世界！
我的名字叫做: 川川
1
2

五、构造函数

Java 中的构造函数是一种用于初始化对象的特殊方法。创建类的对象时调用构造函数。它可用于设置对象属性的初始值。跟其它的语言都差不多的。
例如：

package mian;

public class num_18 {
	int x;//设置属性
	//为 num_18 类创建一个类构造函数
	public num_18()
	{
		x=6;//初始化属性值
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_18 s=new num_18();//创建对象s
		System.out.println(s.x);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

执行：6

注意：构造函数名称必须与类名称匹配，并且它不能有 返回类型（如void）

5.1构造函数参数

构造函数也可以带参数，用于初始化属性。
以一个加法为例：

package mian;

public class num_19 {
	 int x;

	  public num_19(int y) {
	    x = y+2;
	  }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_19 s=new num_19(5);
		System.out.println(s.x);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

执行：7

5.2多个参数

同样也可以传入多个任意数量的参数，

package mian;

public class num_20 {
	int age;
	String name;
	float money;//声明属性
	
	public num_20(int nage,String nname,float nmoney)
	{
		age=nage;
		name=nname;
		money=nmoney; 
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_20 s=new num_20(20,"张三",1000);
		System.out.println("年龄为："+s.age);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

执行：年龄为：20

六、修饰符

public关键字是访问修饰符，意味着它用于设置类、属性、方法和构造函数的访问级别。
修饰符可以分为两组：

• 访问修饰符- 控制访问级别
• 非访问修饰符- 不控制访问级别，但提供其他功能

6.1访问修饰符

default例子：

class hello {
  public static void main(String[] args) {
    System.out.println("你好世界");
  }
}
1
2
3
4
5

对于属性、方法和构造函数，可以使用以下之一：

protected例子（给后续继承会学，不着急）：

class Person {
  protected String fname = "川川";
  protected String lname = "菜鸟";
  protected String email = "hello@doe.com";
  protected int age = 22;
}

class Student extends Person {
  private int graduationYear = 2022;
  public static void main(String[] args) {
    Student myObj = new Student();
    System.out.println("Name: " + myObj.fname + " " + myObj.lname);
    System.out.println("邮箱: " + myObj.email);
    System.out.println("年龄: " + myObj.age);
    System.out.println("年份: " + myObj.graduationYear);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6.2非访问修饰符

对于属性和方法，可以使用以下当中之一：

6.3final

如果不想覆盖现有属性值，需要属性声明为final：

package mian;

public class num_21 {
	final int x=5;
	final int y=6;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_21 s=new num_21();
		s.x=10;//覆盖
		s.y=9;//覆盖
		System.out.println(s.x);//会报错
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6.4static

方法static意味着可以在不创建类的对象的情况下访问它，不像public（需要创建对象才能访问）：

package mian;

public class num_22 {
	//static方法
	 static void pr() {
		    System.out.println("川川");
		  }
	 //public方法
	 public void xue() {
		 System.out.println("菜鸟");
	 }
	 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		pr();//直接访问
		num_22 s=new num_22();//创建方法s
		s.xue();//访问s对象的方法；
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

执行：

川川
菜鸟
1
2

6.5abstract

abstract方法属于一个类abstract，它没有主体。主体由子类提供。
编写抽象类num_23.java:

package mian;


//抽象类
abstract class Main {
	  public String name = "川川";
	  public int age = 24;
	  public abstract void study(); // 抽象方法
	}


//再定义子类
class num_23 extends Main {
	  public int graduationYear = 2022;
	  public void study() { 
	  System.out.println("终身学习"); 
	  }
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

编写主程序num_24.java:

package mian;

public class num_24 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		num_23 s=new  num_23();//创建对象
		System.out.println("名字为："+s.name);
		System.out.println("年龄为："+s.age);
		s.study(); //调用抽象方法
		
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行：

名字为：川川
年龄为：24
终身学习
1
2
3

七、封装

封装就是要确保对用户隐藏数据的保护，封装需要确保：

• 将类变量/属性声明为private
• 提供公共get 和set方法来访问和更新private 变量的值

在上一节，我们指导private变量只能在同一个类中访问（外部类无法访问它）。但是，如果我们提供公共的get和set方法，就可以访问它们。get方法返回变量值，set方法设置该值，两者的语法都是以getor开头set，后跟变量名，第一个字母大写。
person.java:

package mian;

public class person {
	private String name; 
	//取出name
	public String getName() {
	    return name;
	  }

	 public void setName(String newName) {
		    this.name = newName;
		  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

其中：this关键字用于引用当前对象。但是，由于name变量声明为private，我们 无法从此类外部访问它。

package mian;

public class main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		person s=new person();//创建对象
		s.name="张三"; //修改.会报错。
		System.out.println(s.name); //访问。会报错。
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

直接访问就会报错。如果变量被声明为public，就会可以访问到了

如果不修改为public,可以通过方法来修改：

package mian;

public class main {

	public static void main(String[] args) {
		person s=new person();//创建对象
		s.setName("川川"); //修改
		System.out.println(s.getName()); //访问
	}
}
1
2
3
4
5
6
7
8
9
10

执行：

为什么要封装？

• 更好地控制类属性和方法
• 类属性可以设为只读（如果只使用get方法）或只写（如果只使用set方法）
• 灵活：程序员可以更改代码的一部分而不影响其他部分
• 提高数据的安全性

八、包

包分为两类：

• 内置包（来自 Java API 的包）
• 用户定义的包（创建自己的包）

8.1 内置包

Java API 是一个预先编写的类库，可以免费使用，包含在 Java 开发环境中。该库分为包和类。这意味着可以导入单个类（及其方法和属性），也可以导入包含属于指定包的所有类的整个包。

要使用库中的类或包，需要使用import 关键字：

import package.name.Class;   // 导入单个类
import package.name.*;   // 导入整个库
1
2

8.2导入一个类

最常见就是用户输入类，Scanner类：

import java.util.Scanner;
1

举个例子：使用nextLine()用于读取完整行

package mian;
import java.util.Scanner;
public class num_25 {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
	    System.out.println("请输入名字：");

	    String userName = s.nextLine(); //读取整行
	    System.out.println("名字为: " + userName);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

执行：

8.3导入包

要导入整个包，请以星号 ( *) 结束句子。例如下面的案例：

package mian;
import java.util.*;
public class num_25 {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
	    System.out.println("请输入名字：");

	    String userName = s.nextLine(); //读取整行
	    System.out.println("名字为: " + userName);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

执行：

8.4定义包

使用package关键字，例如：

package bao;

class test { 
	  public static void main(String[] args) { 
	    System.out.println("CSDN:川川菜鸟!"); 
	  } 
	}
1
2
3
4
5
6
7

九、继承

在 Java 中，可以将属性和方法从一个类继承到另一个类。继承分为两大类：

• subclass (child) - 从另一个类继承的类
• superclass (parent) - 继承自的类

要从类继承，需要使用extends 关键字。继承格式：

class 父类 {
}
 
class 子类 extends 父类 {
}
1
2
3
4
5

例如下面案例：

package mian;

class SuperClass {
	  private int n; //属性
	  SuperClass(){  //方法1
	    System.out.println("川川");
	  }
	  SuperClass(int n) {  //传参的方法2
	    System.out.println("菜鸟");
	    this.n = n;
	  }
	}
// SubClass 类继承 SuperClass
class SubClass extends SuperClass{
  private int n; //属性
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("自动调用");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("参数为:"+n);
    this.n = n;
  }
}
	
public class num_26{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

执行：

如果不希望其他类从某个类继承，请使用final关键字：

final class SuperClass {
  ...
}

class Car extends SuperClass {
  ...
}
1
2
3
4
5
6
7

个人微信：hxgsrubxjogxeeag
1