java中的类语法和前端的类语法几乎是一致的。
基础代码示例
JAVA的面向对象编程和JS的类语法十分接近，我们看一段代码
public class Object_oriented {
public static void main(String[] args) {
// 打工人 前的PeoPle是类型
People dagongren =new People();
dagongren.name = "zhangsan";
dagongren.speak();
}
}
class People {
String name;
void speak(){
System.out.println("卧槽，" + name +"讲话了！");
}
}
上述代码包含一个名为Object_oriented的Java类和一个名为People的Java类。
Object_oriented类是程序的入口点，具有一个静态的main方法，是程序的执行起点。在main方法中，创建了一个People对象，名为dagongren，并设置了其name属性为"zhangsan"。接着调用了dagongren对象的speak方法。
People类是一个自定义的类，具有一个name属性和一个speak方法。name属性是一个字符串，存储了一个人的名字。
类的属性
在Java类中，属性也称为成员变量或实例变量，是类的特征和状态的表示。
属性可以是任何基本数据类型（如整数、浮点数、字符、布尔值等）或引用数据类型（如字符串、数组、对象等）。
属性的声明语法如下：
<访问修饰符> <数据类型> <属性名>;
访问修饰符用于控制属性的可见性和访问范围：
- public：可以从任何地方访问。
- private：只能在同一个类中访问。
- protected：可以在同一个包内或子类中访问。
- 默认（不写修饰符）：可以在同一个包内访问。
例如，以下是一个包含三个属性的示例：
public class Person {
public String name; // 公开的name属性
private int age; // 私有的age属性
protected boolean sex; // 受保护的sex属性
// 构造方法和其他方法...
}
在上面的示例中，Person类有三个属性：name、age和sex。name属性是公开的，可以从类外部访问。age属性是私有的，只能在Person类内部访问。sex属性是受保护的，可以在同一个包内或Person类的子类中访问。
类的方法
类的方法和TS中的方法基本一致，类中的方法需要添加返回类型
方法由方法头和方法体组成。方法头包括方法的修饰符、返回类型、方法名称和参数列表。
修饰符 返回类型 方法名(参数列表) {
// 方法体
}
- 修饰符指定方法的访问方式（public、private、protected等）
- 返回类型指定方法返回的数据类型（如果没有返回值则使用关键字void）
- 方法名是方法的标识符
- 参数列表列出方法接受的参数。
我们可以看一个简单的demo
public class Object_oriented {
public static void main(String[] args) {
People dagongren =new People();
dagongren.eat = true;
dagongren.speak();
}
}
class People {
boolean eat;
void speak(){
System.out.println(getText());
}
String getText(){
if(this.eat) {
return "我吃饭了";
}else {
return "我没吃饭";
}
}
}
方法中引入类的属性可以使用this关键词
方法中可以引入类中的其他方法
如果类中的方法需要参数，其写法和js也是一致的，不过需要指定参数的类型，如
public void add(int num1, int num2) {
// 方法体
}
静态
静态成员
静态变量是与类关联的变量，可以理解为类自身的属性，实例对象是木有的。静态变量可以用类名直接访问，而不需要创建类的实例。例如：
public class MyClass {
static int count;
}
使用类名访问静态成员变量。例如：MyClass.count = 10;
静态方法
静态方法是与类关联的方法。与静态变量一样，无需创建类的实例即可访问静态方法。
使用类名调用静态方法。例如：MyClass.printMessage();
静态块
通过使用 static 关键字定义，用于在类加载时执行一次的初始化操作。静态代码块在类首次被加载时执行，并且在类中的其他静态成员之前执行。
public class test {
public static void main(String[] args) {
new People();
new People();
}
}
class People {
static {
System.out.println("静态代码块1-------------------------------");
}
static {
System.out.println("静态代码块3-------------------------------");
}
}
实例代码块
没有使用任何关键字定义，直接写在类中的代码块。实例代码块在创建对象时被调用，每次创建对象都会执行。通常用于在创建对象时进行一些通用的初始化操作。
public class test {
public static void main(String[] args) {
new People();
new People();
}
}
class People {
{
System.out.println("实例代码块2-------------------------------");
}
}
静态代码块与实例代码的区别
public class test {
public static void main(String[] args) {
new People();
new People();
}
}
class People {
static {
System.out.println("静态代码块1-------------------------------");
}
{
System.out.println("实例代码块2-------------------------------");
}
static {
System.out.println("静态代码块3-------------------------------");
}
}
可见:
- 静态代码块优先级最高，只执行一次
- 实例代码块优先级低，每次实例都执行
构造方法
构造方法是一种特殊的方法，用于创建并初始化对象。构造方法的名称必须与类名相同，并且没有返回类型。这和js类中的constructor是一致的
构造方法有以下特点：
- 构造方法在使用new关键字创建对象时被调用，且只调用一次。
- 构造方法可以有多个重载版本，即可以根据不同的参数列表创建不同的构造方法。
- 如果没有显式定义构造方法，Java会隐式地提供一个无参的默认构造方法，用于创建对象。
public class test { public static void main(String[] args) { new People(); new People(); } } class People { People(){ System.out.println("构造方法-------------------------------"); } }
构造方法与静态块的执行顺序
public class test { public static void main(String[] args) { new People(); new People(); } } class People { static { System.out.println("静态代码块1-------------------------------"); } { System.out.println("实例代码块2-------------------------------"); } People(){ System.out.println("构造方法-------------------------------"); } static { System.out.println("静态代码块3-------------------------------"); } }
可见，优先级顺序 静态块 > 实例块 > 构造方法
继承
Java中的继承语法格式如下：
class Subclass extends Superclass {
// 子类的方法和属性
}
其中，Subclass是子类，Superclass是父类。
我们看下面这个具体示例：
class Animal {
public void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("Dog is barking");
}
}
public class Test {
public static void main(String args[]) {
Dog d = new Dog();
d.eat(); // 继承自Animal类
d.bark(); // 继承自Dog类
}
}
在上面的例子中，Dog类继承了Animal类。因此，Dog类可以使用Animal类中定义的eat()方法。同时，Dog类还定义了自己的bark()方法。
this关键字
如果上述Animal类需要一个入参来指定eat的内容，Animal类需要做一些更改
class Animal {
String food;
// 我们在构造方法中使用this改变了类的属性food的值
public Animal(String food){
this.food = food;
}
public void eat() {
System.out.println("狗吃了" + this.food);
}
}
this关键字可以用于访问当前类的成员变量和方法。
super
此时，Dog在继承Animal类时，也需要访问父类的成员变量food
class Dog extends Animal {
public Dog(String food){
// 使用super()可以调用父类的构造方法
super(food);
}
public void bark() {
System.out.println("Dog is barking");
}
}
super关键字用于访问父类的成员变量和方法，super()必须是构造方法中的第一条语句
完整代码
public class Test {
public static void main(String args[]) {
Dog d = new Dog("火腿肠");
d.eat(); // 继承自Animal类
d.bark(); // 继承自Dog类
}
}
class Animal {
String food;
public Animal(String food){
this.food = food;
}
public void eat() {
System.out.println("狗吃了" + this.food);
}
}
class Dog extends Animal {
public Dog(String food){
super(food);
}
public void bark() {
System.out.println("Dog is barking");
}
}
多态
多态是面向对象编程中的一个重要特性，它允许一个对象在不同的上下文中表现出不同的行为。在Java中，多态性是通过继承和方法重写来实现的。
我们看一个示例：
class Animal {
void name (){
System.out.println("所有动物都有名字");
}
}
class Dog extends Animal {
void speak (){
System.out.println("狗喜欢叫");
}
}
上述代码中，我们定义了一个Animal类，Dog类继承了Animal类。
我们实例化一个Animal类，它的name方法自然可以执行。
public class Test {
public static void main(String args[]) {
Animal dw = new Animal();
dw.name();
}
}
现在，我们实例化一个Dog类，注意，Dog的实例有两种类型，Animal和Dog
public class Test {
public static void main(String args[]) {
Animal dw = new Animal();
dw.name();
Animal dog1 = new Dog();
Dog dog2 = new Dog();
}
}
Animal类型的dog1只有name方法，而Dog类型的dog2有speak和name方法
public class Test {
public static void main(String args[]) {
Animal dog1 = new Dog();
dog1.name();
Dog dog2 = new Dog();
dog2.speak();
dog2.name();
}
}
这就是多态。多态是面向对象编程中的一个重要特性，它允许一个对象在不同的上下文中表现出不同的行为。在Java中，多态性是通过继承和方法重写来实现的。
重载
假设我们有一个登录方法，这个方法可以通过不同形式登录。如果我们在类中写两个完全一致的函数login名，会报错。
一个类中，不能重复声明相同的方法，相同的属性
我们也许会想到写一个login函数，通过if-else来实现逻辑。但是，在java中，使用函数重载，能更好的解决这个问题。
当我们给login函数定义不同的入参时，报错就取消了。
如果方法名相同，但是参数列表（个数、顺序、类型）不同，会认为是不同的方法。这个操作在JAVA中称之为方法的重载。
构造函数的重载
构造函数也是支持重载的
package top;
public class Test {
public static void main(String args[]) {
Login p1 = new Login();
Login p2 = new Login("张三");
Login p3 = new Login("张三","女");
}
}
class Login {
Login(){
}
Login(String name){
}
Login(String name,String sex){
System.out.println(name + sex);
}
}
此外，我们还可以借助this关键词来在构造函数中调用其他的重载函数
package top;
public class Test {
public static void main(String args[]) {
Login p1 = new Login();
}
}
class Login {
Login(){
this("张三");
}
Login(String name){
this(name,"女");
}
Login(String name,String sex){
System.out.println(name + sex);
}
}
