类:由属性和行为组成
属性:在类中通过成员变量来体现
行为:在类中通过成员方法来体现
public class 类名{
//成员变量
变量1的数据类型 变量1;
变量2的数据类型 变量2;
...
//成员方法
方法1;
方法2;
...
}
在Java中,类是描述具有相同属性和行为的对象的蓝图。通过定义类,可以创建
多个实例,即对象。对象是类的具体实现,并且可以使用其属性和方法来完成特
定的任务。
封装是将数据和操作组合起来,以便通过类的接口访问它们。通过将数据字段隐
藏在类的内部,并提供公共方法来访问和修改数据,可以保护数据的完整性和安
全性。
继承是指一个类获得另一个类的属性和方法。通过继承,子类可以重用父类的代
码,并且还可以添加自己的特定功能。在Java中,使用关键字extends实现继承
关系。
多态是指一个对象可以表现出多种形态或类型。通过多态,可以使用统一的接
口来处理不同类型的对象,提高代码的可复用性和可拓展性。在Java中,多态
可以通过方法的重写和接口的实现来实现。
抽象类是无法被实例化的类,它可以包含抽象方法和非抽象方法。抽象方法只有
声明而没有具体实现,需要子类去实现。接口定义了一组方法的规范,任何类都
可以实现一个或多个接口。不同类之间通过继承抽象类或实现接口来共享代码
和行为。
除此之外还有其他一些与面向对象相关的概念,如构造函数、方法重载、访问修饰符等。理解这些基础知识也很重要。
定义一个新的手机类并在这个类中使用
。
public class crj {
public static void main(String[] args) {
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);
p.brand = "小米";
p.price = 2999;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendPassage();
}
}
新定义一个学生类,并在这个类中使用
。
public class crj {
public static void main(String[] args) {
Student s = new Student();
//调用成员变量
s.name="高启强";
s.age=39;
System.out.println(s.name+s.age);
//调用成员方法
s.study();
s.doHomework();
}
}
public class Student {
//成员变量
String name;
int age;
//private int age;
public void setAge(int a) {
// age = a;
if (a < 0 || a > 120) {
System.out.println("年龄有误");
} else {
age = a;
}
}
//成员方法
public void study() {
System.out.println("好好学习");
}
public void doHomework() {
System.out.println("多加练习");
int j = 0;
}
public void show() {
System.out.println(name + "," + age);
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
是一个权限修饰符
可以修饰成员
作用:保护成员不被别的类使用,
被private修饰的成员只在本类中才能访问
使用方法
提供get变量名()用于获取成员变量的值,方法用public修饰
set变量名(参数)用于设置成员变量的值方法用public修饰
在Java中,private是一种访问修饰符(access modifier),用于控制类
的成员(字段和方法)的可见性。具体来说,private修饰的成员只能在所
属类的内部访问,而在类的外部是不可见的。
使用private关键字可以实现封装(encapsulation)的概念,将类的内部
数据和实现细节隐藏起来,只暴露必要的接口给外部使用。这样做的好处是
可以提高代码的安全性和可维护性,防止外部代码直接访问类的私有成员,
从而避免不经意间改变了类的内部状态。
下面演示了private关键字的使用:
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("Hello, my name is " + name);
}
private void increaseAge() {
age++;
}
public void celebrateBirthday() {
increaseAge();
System.out.println("Happy birthday! Now I'm " + age + " years old.");
}
}
在上述代码中,name和age字段被声明为private,只能在Person类的内部访
问。sayHello方法是公有方法,可以被外部代码调用。increaseAge方法被声明
为private,只能在Person类的内部调用。
这意味着,当我们创建一个Person对象并调用celebrateBirthday方法时,
age的增加是在类的内部发生的,外部代码无法直接访问和更改age的值。
Person person = new Person("Alice", 25);
person.sayHello(); // 正确,输出:Hello, my name is Alice
person.increaseAge(); // 错误,无法调用私有方法
System.out.println(person.age); // 错误,无法访问私有字段
person.celebrateBirthday(); // 正确,输出:Happy birthday! Now I'm 26 years old.
private关键字用于限制类的成员的访问范围,只允许在所属类的内部访问。通
过使用private关键字,可以实现封装,提高代码的安全性和可维护性。
在类的方法内部,如果局部变量和实例变量同名,可以使用this关键字来指定访
问实例变量。例如:this.variableName。
在类的某个方法内部,可以使用this关键字来调用当前对象的其他方法。
例如:this.methodName()。
在一个类中,可以定义多个构造方法,通过使用不同的参数列表进行重载。如果
一个构造方法需要调用另一个构造方法,可以使用this关键字。
例如:this(parameters)。
public class crj {
public static void main(String[] args) {
Student2 s = new Student2();
s.setName("林清玄");
s.setAge(30);
System.out.println(s.getName()+","+s.getAge());
}
}
public class Student2 {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge(){
return age;
}
}
创建 如果没有定义,系统将给出一个默认的无参构造方法
如果定义了,系统将不再提供默认构造方法
重载 如果自定义了带参构造方法,还想使用无参构造方法,就必须再写
一个无参构造方法
推荐 永远提供无参构造方法
构造方法名称必须与类名完全相同,大小写也要匹配。
构造方法没有返回类型,连 void 关键字也不需要。
如果没有显式地定义构造方法,Java 会自动为类定义一个默认的无参构
造方法。
如果自定义了有参数的构造方法,Java将不会自动创建无参构造方法。这
就意味着,如果需要创建一个对象,必须显式地提供一个无参构造方法。
如果类中同时存在无参构造方法和有参构造方法,那么在创建对象时默认
首选无参构造方法。
构造方法可以重载,也就是说可以定义多个具有不同参数列表的构造方法,
以应对不同的对象创建需求。
在子类中,构造方法的第一行必须是调用父类的构造方法,否则编译器会自
动添加默认的 super() 方法调用。