JAVA基础:面向对象++封装+继承【超详细】一、创建对象创建类和对象为num_1: 演示： \ 二、对象的属性 X在

一、创建对象

创建类和对象为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);\
}

}

演示：

二、对象的属性

X在以上中是变量，它实际上是类的一个属性。或者可以说类属性是类中的变量。

例如：创建一个名为 " num_2" 的类，具有两个属性：x和y：

public class num_2 {\
int x=1;\
int y=2;\
public sta\
}

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);

}
```

}

演示：

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);//打印修改后的属性值\
}\
}

也可以直接覆盖：

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);//打印修改后的属性值\
}

}

如果不想覆盖现有值，将属性声明为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);//打印修改后的属性值\
}

}

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

三、方法（函数）

3.1什么是方法？

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

创建一个方法test：

public class num_5 {\
static void test() {\
System.out.println("川川菜鸟");\
}

调用定义的方法：

package mian;

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

}

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

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();\
}

}

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("李四");\
}

}

输出为：

名字为：张三\
名字为：李四

同理也可以数字参数：

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);\
}

}

输出为：

数字为：2\
数字为：3

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);\
}\
}

输出为：

张三年龄为：22\
李四年龄为：20

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));\
}

}

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

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));\
}\
}

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);

}
```

}

演示：

3.6方法重载

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

int myMethod(int x)\
float myMethod(float x)\
double myMethod(double x, double y)

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

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);
    }
```

}

四、类的方法

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

package mian;

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

}

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方法\
}\
}

执行为：

static方法\
public方法

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("张三");     
  }
```

}

执行：

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

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);
  }
```

}

创建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("川川");
}
```

}

执行：

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

五、构造函数

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);\
}

}

执行：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);
}
```

}

执行：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);
}
```

}

执行：年龄为：20

六、修饰符

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

修饰符可以分为两组：

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

6.1访问修饰符

修饰符	描述
public	任何其他类都可以访问该类
default	就是默认的类，比如打印"hello"

default例子：

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

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

修饰符	描述
public	所有类都可以访问该代码、f方法
private	代码只能在声明的类中访问
protected	该代码可在相同的包和子类中访问

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

class Person {\
protected String fname = "川川";\
protected String lname = "菜鸟";\
protected String email = "";\
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);\
}\
}

6.2非访问修饰符

修饰符	描述
final	该类不能被其他类继承
abstract	该类不能用于创建对象

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

修饰符	描述
final	属性和方法不能被覆盖/修改
static	属性和方法属于类，而不是对象
abstract	只能在抽象类中使用，并且只能在方法上使用。该方法没有主体，例如 abstract void run();。主体由子类提供
transient	序列化包含它们的对象时忽略属性和方法
synchronized	方法一次只能被一个线程访问
volatile	属性的值不会在线程本地缓存，并且总是从“主内存”中读取

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);//会报错\
}

}

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对象的方法；
}
```

}

执行：

川川\
菜鸟

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("终身学习"); 
  }
}


编写主程序num_24.java:

<pre class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">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(); //调用抽象方法

}


}</pre>

执行：

<pre class="hljs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">名字为：川川\
年龄为：24\
终身学习</pre>

## 七、封装

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

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

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

person.java:

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">package mian;

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

public void setName(String newName) { this.name = newName; }


}</pre>

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

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">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); //访问。会报错。

}


}</pre>

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

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3934d1abc067427d8e251a056ad9e835~tplv-k3u1fbpfcp-zoom-1.image)\


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

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">package mian;

public class main {

public static void main(String[] args) { person s=new person();//创建对象 s.setName("川川"); //修改 System.out.println(s.getName()); //访问 }


}</pre>

执行：

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5619ebea109d4ce7ac330d9e79f4eaa6~tplv-k3u1fbpfcp-zoom-1.image)\


为什么要封装？

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

包分为两类：

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

### 8.1 内置包

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

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

<pre class="prettyprint hljs gradle" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">import package.name.Class; // 导入单个类\
import package.name.*; // 导入整个库</pre>

### 8.2导入一个类

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

<pre class="hljs css" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">import java.util.Scanner;</pre>

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

<pre class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">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);

}


}</pre>

执行：

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/730351fdb76844a99a2e8e45413ce54f~tplv-k3u1fbpfcp-zoom-1.image)\


### 8.3导入包

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

<pre class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">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);

}


}</pre>

执行：

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d044a2ef278942e596b542da7ad74b79~tplv-k3u1fbpfcp-zoom-1.image)\


### 8.4定义包

使用package关键字，例如：

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">package bao;

class test {

public static void main(String[] args) {

System.out.println("CSDN:川川菜鸟!");

} }


## 九、继承

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

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

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

<pre class="prettyprint hljs scala" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">class 父类 {\
}

class 子类 extends 父类 {\
}</pre>

例如下面案例：

<pre class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">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);

}\
}</pre>

执行：

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/bdfec6f5b5b24c6889f32d8538274cdb~tplv-k3u1fbpfcp-zoom-1.image)\


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

<pre class="prettyprint hljs scala" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">final class SuperClass {\
...\
}

class Car extends SuperClass {\
...\
}</pre>