一、创建对象
创建类和对象为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 stubnum_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 = "[email protected]";
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:
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(); //调用抽象方法 }}
执行：
名字为：川川
年龄为：24
终身学习
七、封装
封装就是要确保对用户隐藏数据的保护，封装需要确保：
- 将类变量/属性声明为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; }}
其中：this关键字用于引用当前对象。但是，由于name变量声明为private，我们 无法从此类外部访问它。
package mian;直接访问就会报错。如果变量被声明为public，就会可以访问到了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); //访问。会报错。 }}
如果不修改为public,可以通过方法来修改：
package mian;public class main {
public static void main(String[] args) { person s=new person();//创建对象 s.setName("川川"); //修改 System.out.println(s.getName()); //访问 }}
执行：
为什么要封装？
- 更好地控制类属性和方法
- 类属性可以设为只读（如果只使用get方法）或只写（如果只使用set方法）
- 灵活：程序员可以更改代码的一部分而不影响其他部分
- 提高数据的安全性
包分为两类：
- 内置包（来自 Java API 的包）
- 用户定义的包（创建自己的包）
8.1 内置包
Java API 是一个预先编写的类库，可以免费使用，包含在 Java 开发环境中。该库分为包和类。这意味着可以导入单个类（及其方法和属性），也可以导入包含属于指定包的所有类的整个包。
要使用库中的类或包，需要使用import 关键字：
import package.name.Class; // 导入单个类
import package.name.*; // 导入整个库
8.2导入一个类
最常见就是用户输入类，Scanner类：
import java.util.Scanner;
举个例子：使用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); }}
执行：
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); }}
执行：
8.4定义包
使用package关键字，例如：
package bao;class test {
public static void main(String[] args) { System.out.println("CSDN:川川菜鸟!"); } }
九、继承
在 Java 中，可以将属性和方法从一个类继承到另一个类。继承分为两大类：
- subclass (child) - 从另一个类继承的类
- superclass (parent) - 继承自的类
要从类继承，需要使用extends 关键字。继承格式：
class 父类 {
}
class 子类 extends 父类 {
}
例如下面案例：
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);}
}
执行：
如果不希望其他类从某个类继承，请使用final关键字：
final class SuperClass {
...
}
class Car extends SuperClass {
...
}