Java拾贝不建议作为0基础学习，都是本人想到什么写什么
特性
封装性，继承性，多态性。
类的组成
public class 类名 {
//数据类型 属性名;
int age;//成员变量
public 返回值类型 方法名(传参) {
String name;//局部变量
//方法体
}
}
其中定义在类中的属性名也就是变量名，也叫字段名，也叫成员变量 有本事名字再多一点
若定义在方法中的属性称之为局部变量。
简单的栗子
public class Person {
String name;
int age;
public void tell() {
System.out.println("嘟嘟嘟~"+name+"，"+age);
}
}
//你知道Person类中包含哪些内容吗？
面向对象的概念
可以把对象当作待涂鸦的纯白雕塑，其模板是固定的。
更多的内容需要后续进行加工补充。
继续用上述Person类举例，现在创建对象并且使用它(也叫实例化)
//类名 变量名=new 类名();
public class test2 {
public static void main(String[] args) {
Person p =new Person();//实例化一个对象p
}
}
class Person{
String name;
int age;
public void tell() {
System.out.println("嘟嘟嘟~"+name+"，"+age);
}
}
现在已经实例化成功了，执行一下tell方法
要使用对象访问其属性值或方法操作如下
对象名.属性名;
对象名.方法名();
public static void main(String[] args) {
Person p =new Person();
p.tell();
}
//嘟嘟嘟~null，0
调用成功了，打印结果有null和0的原因是还没有给变量赋值，所以输出的是属性的默认值
现在需要修改其属性值使输出不再使用默认值。
public static void main(String[] args) {
Person p =new Person();
p.name="张三";
p.age=18;
p.tell();
}
//嘟嘟嘟~张三，18
创建多个对象
public class test2 {
public static void main(String[] args) {
Person p1 =new Person();
p1.name="张三";
p1.age=18;
p1.tell();
Person p2 =new Person();
p2.name="李四";
p2.age=19;
p2.tell();
}
}
class Person{
String name;
int age;
public void tell() {
System.out.println("嘟嘟嘟~"+name+"，"+age);
}
}
/*
嘟嘟嘟~张三，18
嘟嘟嘟~李四，19
*/
p1和p2各拿了一个雕像进行涂鸦，所以不会影响到彼此的内容
现在把p1赋值给p2，让其操作的是一个雕像然后进行修改内容。
public static void main(String[] args) {
Person p1 =new Person();
p1.name="张三";
p1.age=18;
p1.tell();
Person p2 =p1;
p2.age=19;
p2.tell();
}
/*
嘟嘟嘟~张三，18
嘟嘟嘟~张三，19
*/
从结果上看p2成功修改了p1的一部分涂鸦，让其沾上了自己的颜色！
上述栗子其实是所谓的引用传递
各拿一个雕像进行涂鸦的时候。其实就是堆内存中开辟了两个空间，然后栈内存中p1和p2各指向一个空间。
p2操作p1雕像的时候。其实就是堆内存中开辟了一个空间，然后栈内存中的p1指向唯一的空间，p2也指向唯一的空间。所以会导致p2成功涂鸦p1的雕像
//有时候也会有特殊情况
Person p2 = new Person();
p2.name = "李四";
p2.age = 19;
p2 = p1;
原本p2好好的结果突然指向了p1的雕像，这就会导致p2原来的空间形成垃圾空间。
垃圾空间会等待Java本身提供的垃圾回收机制(GC)来释放空间。
因为一个栈内存空间只能指向一个堆内存空间。
封装性
面向对象的第一大特性，封装即包装好。使得外部不可见
在上面的栗子中Person类的成员属性可以被任意的访问并修改。封装就可以保护好类中的属性。
要封装属性或方法操作如下
private 数据类型 属性名;
private 返回值类型 方法名(传参){};
是的没错只需要在属性或方法前加上私有的访问修饰符即可封装。试一试
public class test2 {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "张三";
p1.age = 18;
p1.tell();
}
}
class Person {
private String name;
private int age;
public void tell() {
System.out.println("嘟嘟嘟~" + name + "，" + age);
}
}
//报错，甚至编译都无法通过，那么对象p1该怎么去访问属性呢？
在封装完毕的情况下，要怎么去访问属性或者方法呢？
为了解决属性必须封装又必须访问的矛盾，在Java开发中有明确的定义：
“只要是被封装的属性，必须通过getter和settter方法修改和访问”
加上getter和setter方法
public class test2 {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("张三");//setter方法
p1.setAge(18);
p1.tell();
}
}
//this关键字用于访问成员变量
class Person {
private String name;//成员变量
private int age;
public void tell() {
System.out.println("嘟嘟嘟~" + this.name + "，" + this.age);
}
public String getName() {
return name;
}
public void setName(String name) {//this.name为成员变量 name为局部变量
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/*
嘟嘟嘟~张三，18
*/
另外this还可以访问本类中的方法
this.方法名(传参);
public class test2 {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("张三");//setter方法
p1.setAge(18);
p1.tell();
p1.say();
}
}
//this关键字用于访问本类中的方法
class Person {
private String name;//成员变量
private int age;
public void tell() {
System.out.println("嘟嘟嘟~" + this.name + "，" + this.age);
}
public void say() {
this.tell();
}
//getter和setter
}
/*
嘟嘟嘟~张三，18
嘟嘟嘟~张三，18
*/
需要实例化的对象一多，不可能我每个都去setter一下吧？构造方法由此诞生！
构造方法
构造方法主要作用是初始化类中的属性。
- 构造方法必须和类名相同
- 构造方法不能有任何返回值类型(包括void)
- 构造方法不能有return语句。
构造方法格式如下
访问修饰符 构造方法名(传参){
//方法体
};
举个栗子
public class test2 {
public static void main(String[] args) {
Person p1 = new Person("张三",18);//调用构造方法进行对象(实例)初始化
p1.say();
}
}
class Person {
private String name;
private int age;
public Person() {//无参构造方法
}
public Person(String name, int age) {//有参构造方法
this.name = name;
this.age = age;
}
public Person(String name) {//构造方法的重载
this.name = name;
}
public void tell() {
System.out.println("嘟嘟嘟~" + this.name + "，" + this.age);
}
//getter和setter
/*
嘟嘟嘟~张三，18
*/
一类个中通常包括一个默认生成的无参构造方法。
其中，如果定义了有参的构造方法必须显性定义无参构造方法