03--面向对象基础部分随记

1.面向对象的三个特征:

封装：显示器-->外壳-->保护内部零件

继承：用于扩展类的功能；

多态：面向对象中最重要的一部分；

2.类和对象：

类：是具有共同特征和行为的一类事物的统称

对象：对象是类的实例化；

类通过class 定义，包含属性和方法；

对象new的类；

3.封装：java中通过 private实现封装；

即将属性设置成private，然后用setter和getter方法；

将不想让外部访问的属性不舍setter方法，就可以不能

被访问到了。

或者在setter方法中加上条件，这样就起到了封装、检验的作用了；

注：封装的作用就是起到保护作用；这样将属性设为private起到了封装作用；

在setter方法中加上判断条件起到了 检查的作用；

4.String 类中有个public boolean equals(String string)方法，重写了Object中的equals方法；

Object中的equals方法和String中的equals方法的区别：

Object中的该法指的是是否是同一个对象，即引用变量是否指向的同一个对象（即是指向同一块堆内存中的空间）；

String中的该法指的是 引用变量指向的对象的值是否相等，只要值相等，即使不是同一个对象也可，如下：

String s1=new String("test");

String s2=new String("test");

s1.equals(s2)----结果位true；

equals和==的区别：

equals：Object中的该方法指的是是否是堆内存中同一个对象；

String中的该法指的是是否是堆内存中同一个对象，或者两个对象内容是否相同；

==：1.对对象而言：指的是栈内存中两个引用类型变量存放的地址是否相同；

2.对值类型数据而言：指的是两个变量的值是否相同（值类型的变量放在 栈内存中，在栈内存中存放值）

总结特点：对对象而言-----只要== 得到的是true 用equals得到的一定是true；

而equals 得到的是true时 用 == 得到的不一定是true；

5：String name1=“test”，String name2=“test”这时用equals和==得到的都是true，原因是在定义String

变量时会查看堆内存中是否有该值，如果有则直接用该引用类型指向该空间；

String name1=new String("test"),String name2=new String("test")用equals得到的是true，

用==得到的是false；

//以下得到的结果：true

public class Demo{

public static void main(String args[]){

String s1=new String("test");

String s2=new String("test");

System.out.println(s1.equals(s2));

}

}

//以下得到的结果：false

class Person{

private String name;

private int age;

public Person(String name,int age){

this.name=name;

this.age=age;

}

public void setName(String name){

this.name=name;

}

public void setInt(int age){

this.age=age;

}

public String getName(){

return this.name;

}

public int getAge(){

return this.age;

}

}

public class Demo{

public static void main(String args[]){

Person p1=new Person("张三",10);

Person p2=new Person("李四",20);

System.out.println(p1.equals(p2));

}

}

6.String 一旦被创建是不可以改变的；

public class Demo{

public static void main(String args[]){

String name1="张三";

fun(name1);

System.out.println(name1);

}

public static void fun(String name2){

name2="李四";

}

}这个时候输出的结果是：张三；

分析：栈内存 name1 指向 堆内存 的“张三”；

栈内存name2 指向 堆内存的“张三” fun传参是引用类型的传参，只传递地址；

“李四”出现时 堆内存 开辟空间 放“李四”；name2=“李四”这时，name2不指向“张三”而是指向“李四”

这就是String类型变量的值一旦创建不会被改变；

如果fun中name2+="李四"，这时堆内存会开辟空间放 "李四"，在开辟空间放“张三李四”，name2断开指向"张三"去

指向“张三李四”，而堆内存会多出垃圾及“李四”占用的空间；

如果不是String类型的话：

class Person{

String name;

}

public class Demo{

public static void main(String args[]){

Person person1=new Person();

person1.name="张三";

fun(person1)

System.out.println(person1.name);

}

public static void fun(Person person2){

person2.name="李四";

}

}这样输出的结果是：李四；

区别：前者是String 而后者是 Person ，String 不可改变的；

因为String类型是引用类型的person1中的name在栈内存中，指向堆内存中的"张三"；

person2指向person1指向的堆内存，person2中的name其实就是person1中的name，就是栈内存

中指向“张三”的那个name,当出现“李四”时，在堆内存中开辟空间放“李四”，person2.name=“李四”

时，让指向“张三”的那个name指向“李四”；

7.this 的属性：

a:this代表当前对象：---可以调用本类中的属性和方法；

public class Demo{

public static void main(String args[]){

Person person=new Person();

person.setName("张三");

System.out.println(person.getName());

}

}

class Person{

private String name;

private int age;

//如果此处不用this（name=name），则会就近原则，两个name都指的是参数name

public void setName(String name){

this.name=name;

}

public String getName(){

return name;

}

}

b:使用this完成构造方法间的相互调用---减少代码

this()--- 代表无参构造方法，this（String name）--代表有参构造方法；

注意：this()只能在构造方法中代表构造方法；

this()必须放在构造方法的首行；

class Person{

private String name;

private int age;

public Person(){

System.out.println("*******构造方法调用*******");

}

public Person(String name){

System.out.println("*******构造方法调用*******");

this.setName(name);

}

public Person(String name,ing age){

System.out.println("*******构造方法调用*******");

this.setName(name);

this.age=age;

}

public void setName(String name){

this.name=name;

}

public void setAge(int age){

this.age=age;

}

public String getName(){

return this.name;

}

public int getAge(){

return this.age;

}

}

如果用this（）：

class Person{

private String name;

private int age;

public Person(){

System.out.println("*******构造方法调用*******");

}

public Person(String name){

this();

this.setName(name);

}

public Person(String name,ing age){

this(name);

this.age=age;

}

public void setName(String name){

this.name=name;

}

public void setAge(int age){

this.age=age;

}

public String getName(){

return name;

}

public int getAge(){

return age;

}

}

切忌：this()必须在构造方法中；并且必须在构造方法的首行；

8.栈内存---->保存的是对象的名字；

堆内存---->对象的具体内容(属性)；

全局代码区---->所有的方法；

全局数据区---->存放static声明的属性；

9.static的使用：

一个类中写的一个属性，如果使用static声明，则表示此属性为公用属性；

即所有对象都可以访问此属性；

被static声明的属性，可以直接通过类名称调用，而不必通过对象去调用；

注意：static声明的静态方法中不可以出现 this的，因为this代表的是对象；

10.代码块：

普通代码块：是写在一个方法之中的代码块；

构造块：

静态块：

同步代码块(多线程)：

普通代码块：

public class Demo{

public static void main(String args[]){

{

int i=0;

}

int i=10;

System.out.println(i);

}

}

构造块：在类中直接写---构造块早于构造方法执行；执行多次；

class Person{

{

System.out.println("Hello World!!!");

}

Person(){

System.out.println("构造方法");

}

}

public class Demo{

public static void main(String args[]){

new Person();

}

}

静态块：直接写在类中，通过static声明，优先于构造块和构造方法，

作用是为静态属性初始化，只执行一次；

class Person{

static{

System.out.println("static code ……");

}

{

System.out.println("Hello World!!!");

}

Person(){

System.out.println("构造方法");

}

}

public class Demo{

public static void main(String args[]){

new Person();

}

}

同步代码块：

class Demo01 implements Runnable{

private int ticket=10;

public void run(){

synchronized(this){

while(ticket>0){

try{

Thread.sleep(100);

}

catch(Exception e){

}

System.out.println(Thread.currentThread().getName()+"---》卖票:"+ticket--);

}

}

}

}

11. 在java中有个思想：一切皆对象，一切的操作都有对象；

而基本数据类型不是对象，为此java提供了一种对于

基本数据类型 的包装类：8中基本数据类型分别对应

的类：Integer、Character、Float、Double、Byte、Short

、Long、Boolean；