【我的Java笔记】第五课

匿名对象

1.定义：没有名字的对象

2.作用：节省代码。在很多情况下针对某个方法只需调用一次的情况下

      匿名对象可以调用方法，也可以给成员变量赋值，同时也可作为方法的参数进行传递

封装

1.概念：隐藏对象的属性和细节，仅对外提供公共的方法进行访问

2.关键字：“private”

    a.当类的成员变量使用private 修饰符修饰，那么就不可以直接访问到该成员变量
    b. 当使用private 修饰的成员变量或者成员方法，仅能在本类中使用
    c. private 对于main 方法的修饰也可以产生作用的

3.JavaBean类：

    所有成员变量都使用private 进行修饰，并且对外提供可访问的设置值和获取值的set，get方法

    不同的应用场景可能命名不同，在数据库的应用中称为“ POJO ” 类

4.main方法细节：

    a.每个类中都可以存在main方法，但是当执行的时候会优先查看public 的class 中是否有main 方法
    b.如果没有public 的class, 那么会按照文件名优先查找类中的main方法
    c.必须定义为public

例1 private：

       public class DemoPrivate{
public static void main(String[] args){
Person person =new Person();
person.name = "diffo";
person.setAge(20);
person.eat();
person.action();
}

}


class Person{
String name;
private int age;

//获取age
void setAge(int ageParm){
if(ageParm>0 && ageParm<150){
age = ageParm;
}
}

void eat(){
  System.out.println("eat");
}

void action(){
eat();
speak();
}

void speak(){
System.out.println("speak!: "+name+" . "+age);
}
}

例2 JavaBean：

优先原则

对于一个类的成员方法来说，如果传递的形参的变量名称和类的成员变量名称相同，Jvm在处理的时候优先当做方法的形参来处理

“this”关键字

1.含义：代表了对当前对象的引用（当前调用谁，方法中的this即代表谁）

   注：1.对于一个类的成员方法来说，如果传递的形参的变量名称和类的成员变量名称相同，Jvm在处理的时候优先当做方法的形参来处理

           2. 可以加在成员变量的前面来指定对应的引用，也可以加在成员方法的前面

初始化类成员变量的方式

1.在定义成员变量的同时进行赋值
2.提供外界可访问到的方法，在方法中进行赋值
3.通过构造方法进行赋值

   例：

关键字“static”

1.随着类加载而加载
   静态方法区中来保存静态成员变量

2.优先于对象创建
   Person.className = "java";

3.被类的所有对象共享
   静态的成员变量会保存在该class的静态方法区中，所以每个对象看到的都是同一份.

4.可以通过类名来访问也可以通过对象名来访问(效果相同)

5.推荐通过类名来访问
   静态的成员，一般称为类相关的成员

6.static 修饰符既可以修饰成员变量，也可以修饰成员方法。 且修饰之后，就可以通过类名来直接访问到

    类名.方法名 ( )；

7.this 变量在静态方法中不可以使用

8.静态方法中只能访问静态成员变量和静态方法
  非静态方法既可以访问静态成员和方法也可以访问非静态成员和方法（不建议非静态方法去访问静态成员和方法）

例：

main方法

修饰符  返回类型  方法名 (参数列表){

                     ·······

}


public static void main(String[ ] args){


}

1.public: 最大的一个访问权限，使得Jvm能够成功调用
2.static: 类相关的，与对象无关.。通过A.main([ ])；
              例：public class A{
                              main(){
                            System.("   ");
                              }
                       }

3.void: 不需要返回值.
4.方法名: main 
5.参数列表: 执行的时候，可以传递参数

工具类

1.全部都是静态的方法

2.所以可以通过：  类名.functionName( ) 方式来访问
注：（1）一般都会对默认构造方法进行私有化处理，来防止别人使用时习惯性的创建对象来调用方法

         （2）将其中的方法定义为“static”

例：长方形工具类（求边长和面积）

public class User{
	public static void main(String[] args){
		Rectangle rectangle=new Rectangle();
		//赋值
		rectangle.setLength(4);
		rectangle.setWidth(5);
		//调长方形求面积、周长工具
		RectangleUtil.getAre(rectangle);
		RectangleUtil.getCircumLength(rectangle);
	}
}

//长方形类（JavaBean类）
class Rectangle{
	private int length;
	private int width;
	
	void setLength(int length){
		this.length=length;
	}
	int getLength(){
		return this.length;
	}
	
	void setWidth(int width){
		this.width=width;
	}
	int getWidth(){
		return this.width;
	}
}

//长方形工具
class RectangleUtil{
	//私有化此类
	private RectangleUtil(){
	
	}
	
	static void getAre(Rectangle rectangle){
		System.out.println("长方形的面积="+rectangle.getLength()*rectangle.getWidth());
	}
	static void getCircumLength(Rectangle rectangle){
		System.out.println("长方形的周长="+(rectangle.getLength()+rectangle.getWidth())*2);
	}
}

代码块

概念：使用{ } 括起来的代码，称为代码块

分类：根据位置和声明的不同，可将代码块分为：局部代码块、构造代码块、静态代码块和同步代码块（多线程）

一、 局部代码块

  （1）限定了变量的生命周期，变量在局部代码块中定义。出了局部代码块之后，就访问不到了。

            在局部代码块中定义的变量，在出了代码块之后，内存就会释放掉。

  （2）作用: 主要就是节约内存.

  （3）局部代码块中定义的变量，虽然说作用域是局部的，但是如果存在外部嵌套的代码块，且在局部代码块定义之前就定义了某               个变量，那么在我们局部的代码块中就不可以定义相同名称的变量。
  注：但是如果在局部代码块执行之后，去定义一个和局部代码块中相同名称的变量，是可以的。因为局部代码块中的变量已经失去           了作用域范围。

  

  例：

  

二、构造代码块

  （1）概念：在类中的方法外出现，每次调用构造方法的时候，都会优先先调用构造代码块
  （2）特点：每创建一个对象，都会调用一次构造代码块
  （3）作用：如果存在很多重载的构造方法，而且每个里面需要执行相同的逻辑，那么就可以考虑将这些代码提取到构造代码块中                           来执行。可以让我们的代码结构更简练。增强了维护性

三、静态代码块
  （1）概念：类中方法外出现，并用“static” 关键字来进行修饰
  （2）特点：随着类加载的时候执行
  （3）用处：适用于整个软件的生命周期中，只需要执行一次的业务逻辑代码（数据库）

    例：

          

继承

1.特点：

  （1） 子类继承父类的成员变量和成员方法。但是他们各自拥有的各自的成员变量，故父类的值子类并不会继承。

  （2）对于父类中的私有成员变量和私有方法，子类无法继承

2.继承的优点：提高了代码的复用性和维护性

   继承的缺点：类的耦合性增强了（开发的原则：高内聚、低耦合）

      a.耦合: 类和类之间的关系
      b.内聚: 自己独立完成某件事情的能力

3.只支持单继承，但可以多层继承

   继承是相互叠加的。子类继承的时候，会递归似的寻找父类中是否还存在继承，会继承整个层级直到最根部类的属性和方法

4.构造方法无法继承（但可调用父类中的构造方法）

5.继承关系中访问成员变量

 （1）不同名的成员变量

           子类可以直接访问和使用父类继承的非私有的成员变量
 （2）同名的成员变量
           优先原则: 如果子类中定义了和父类中相同名字的成员变量，会 优先访问子类 的该变量
           如果想要依然访问到父类中的同名变量，我们需要加上“super”关键字来获取

 （3）this和super的比较

           this:：对当前对象的引用

super：父类对象的引用

this：可以访问到子类中的变量，也可以访问到父类中的变量
super：访问父类中的变量          

6.继承关系中访问成员方法

  （1）不同名的方法

           子类可直接调用到父类的方法

  （2）同名的方法

          同名方法:：指的返回值类型(父子类关系是可以的)，方法名称以及方法接收的形参列表要一模一样

         注：当子类在调用该同名方法时，会优先调用子类的该方法

7.方法重写

   存在于继承关系中，子类中定义的方法和父类中的方法完全一样的时候(返回值类型父子类关系是可以的),我们在通过子类对象来访问该方法的时候，    就会调用到子类的方法。

  注： 方法重写注意事项：

（1）子类不能重写父类的私有方法
（2）子类重写父类方法的时候，提供的访问权限不能更低.
（3）子类覆盖父类方法，如果父类是静态方法的话，子类也必须是静态方法才可以成功覆盖，也就是重写

8.方法重载

  （1）同一个类中，如果有多个相同方法名的方法，但是他们的形参列表是不同的，那么这种方式我们就称为方法的重载

   在调用时Jvm可以通过不同的形参来区别不同的方法

           注：关于方法重写和方法重载的返回值约束：
方法重载:：仅返回值不同是不能重载的。必须参数列表不同。
方法重写:：返回值类型(父子类关系是可以的) 要求返回值类型也要相同的.

9.继承中构造方法的调用

  （1）特点：

         a.创建子类对象的时候，一定会优先去创建父类的对象。 因为要创建父类对象，所以就需要去调用到父类的构造方法.
 b.对于所有的类的构造方法的第一行，第一行在我们没有自己添加this(...)或者super(...)的情况下都会去帮我们默认的添加super()
         c.如果父类中不存在默认的构造，子类依然要创建对象，那么子类就需要显示的指明调用的是哪一个父类对象，才能保证父类对象创建的成功

  注：a.一定要保证父类对象的创建成功
  b.构造方法的第一行，如果我们添加了自己调用的this(...),或者super(...), 系统就不会为我们默认的添加super().
  c.this(...)或者super(...) 必须放到第一行。二者只能有其一

例1：

/*
在创建子类对象的时候，会先调用到父类的构造方法，去创建父类的对象。
*/

public class ExtendsDemo5{
	
	public static void main(String[] args){
		Son son = new Son();
		System.out.println("-------------");
	}
	
}

class Father{

	Father(){
		System.out.println("father 默认构造");
	}

	
	Father(int num){
		System.out.println("father 有参构造");
	}
}

class Son extends Father{
	
	Son(){
		//super(10);
		this(10); //this(10), 所以就不会帮我们再去默认添加super(),
		System.out.println("son 默认构造");
	}
	
	Son(int num){
		super(10);
		//super(10); //第一行没有this或者super,就会帮我们添加super()
		System.out.println("son 有参构造");
	}
	
	
}

例2：

/*
定义长方形类和正方形类， 长方形继承正方形并且重写计算面积和周长的方法.
*/

public class ExtendsDemo{
	public static void main(String[] args){
		Square square=new Square(3);
		System.out.println("正方形的面积="+square.getAre());
		System.out.println("正方形的周长="+square.getCircumLength());
		
		Rectangle rectangle=new Rectangle(4,5);
		System.out.println("长方形的面积="+rectangle.getAre());
		System.out.println("长方形的周长="+rectangle.getCircumLength());
	}
}

class Square{
	private int length;
	
	Square(int length){
		this.length=length;
	}
	/* 默认构造器
	Square(){
	
	}
	*/
	
	int getAre(){
		return this.length*this.length;
	}
	int getCircumLength(){
		return this.length*4;
	}
}

class Rectangle extends Square{
	private int length;
	private int width;
	
	Rectangle(int length,int width){
		super(1);    //添加父类默认构造器
		this.length=length;
		this.width=width;
	}
	
	int getAre(){
		return this.length*this.width;
	}
	int getCircumLength(){
		return (this.length+this.width)*2;
	}
}

final关键字

1.final修饰类

   若final修饰一个类，该类不能被继承.
2.final修饰类的成员变量

   该成员变量的值不可修改
  注： 在对象创建之前都可以对该变量进行初始化（三种方法同时只可用一种）：
a.构造代码块中可以进行初始化
b.构造方法中可以进行初始化
c.定义成员变量的时候，可以直接进行初始化.

3.在大多数的情况下，final成员变量都会配合public static 一起使用.
例：
//常量类, 变量命名都要大写，而且单词之间要用_分割开.
class A{
   public static final double PI = 3.14;
   public static final double RATE = 2.86;
}

A.PI
A.RATE

4.静态成员变量的初始化时机：
 （1）在创建静态final成员变量的时候，直接进行初始化
 （2）在静态代码块中进行初始化.

           例：static｛

    ·····

   ｝

随堂练习：

/*
 * 定义一个容量为10的数组，其中元素为0到27间的随机数
 * */

import java.util.Arrays;
import java.util.Random;

public class Demo {
	public static void main(String []args){
		
		//方法1：运用Random类做随机数
		/*
		Random r=new Random();
		int [] arr=new int [10] ;
		for(int i=0;i





2017.10.14 /10.15