Java 面向对象编程-（第二天）

Java 面向对象编程-（第二天）

一、面向对象的概念

OOP

抽象的概念称为类(class)   class People{}
具体的对象称为实例(instance)  new People()

类名和java文件名相同。
通过同一个类实例化的对象，它们类型相同，但是属性可能各不相同。

一个class可以包含多个字段（field）。

class People {
	public String name;
	public int age;
}

通过class实现了数据封装。

People xiaoming = new People();   //xiaoming是实例对象的变量名
xiaoming.name = "小明";  
xiaoming.age = 20;

通过变量名·字段来访问字段的值。

System.out.println(xiaoming.name);
System.out.println(xiaoming.age);

二、数据封装-方法

直接把field字段通过public暴露给外部，就破坏了数据的封装。
可以采用private修饰field字段，采用public方法来访问封装的数据。

public class People {
	private String name;
	private int age;
	public void setName(String name){   //void修饰方法表示无返回值
		this.name = name.trim();  //this隐式变量，当字段field名和局部变量名相同时，this不能省略
		//trim()去除字符串前后的空格
	}
	public String getName(){  //String 修饰方法有一个String类型的返回值
		reture this.name;  //return 返回一个String类型的值
	}
	
public static void main(String[] args){
		People xiaoming = new People();
		xiaoming.setName("小明");
		System.out.println(xiaoming.getName());
	}
}

通过**变量名·方法名()**来访问字段的值。
内部可以调用private方法。

三、数据封装-构造方法

通过创建实例直接初始化字段field的值。
构造方法名和类名相同，构造方法没有返回值，参数没有限制。

public class People {
	private String name;
	private int age;
	public People(String name,int age){  //无返回值，无void修饰符
		this.name = name;
		this.age = age;
	}
	public People(String name){  //无返回值，无void修饰符
		this.name = name;
	}
	public People(){  //无返回值，无void修饰符
		
	}
}

字段的初始化顺序：字段的默认值->构造方法->实例变量赋值
多个同名构造方法，编译器通过构造方法参数的数量、位置和类型区分。

四、数据封装-方法重载

overload 多个方法的方法名相同，各自的参数不同（参数个数不同，参数类型不同，参数位置不同），但是返回值类型通常是相同的。

public void setInformation(String name,int age){}
public void setInformation(String set,double scores,String address){}
public void setInformation(String name){}

五、继承

extends
代码复用的一种方式。两个class类中有相同的字段、方法等。
所有的类都继承于object基类，一个类只能继承自一个类，一个类仅有一个父类。

扫描二维码关注公众号，回复： 10691952 查看本文章

继承树
父类中private修饰的字段，子类不可以访问
父类中protected修饰的字段，子类可以访问

如果父类没有默认构造方法，子类的构造方法，第一个语句必须是super()语句

public 类名(){} //默认构造方法，无参数，无返回值，无执行语句

定义一个类时，其实就是定义对象的类型。
实例变量向上转型
向下转型 可能存在错误
实例变量 instanceof 类型 （判断方法）

六、多态

方法覆写@override
子类覆写父类的方法

@override
public class People {
	public void run(){执行语句}
}

public class Student extends People{
	@override
	public void run(){执行语句}
}
//方法名相同，返回值相同，参数相同，但是方法执行语句不同。

引用变量的声明类型可能与实际类型不符

Student s = new Student();
People p = new Student();
p.run();//运行的是实例对象Student的run方法
s.run();//运行的是实例对象Student的run方法

Java的实例方法调用时基于运行时实际类型的动态调用称为多态
进行功能的扩展
super.run()调用父类的方法。

final修饰的方法不能被Override覆写
final修饰的类不能被extends继承
final修饰的字段不能被修改

七、抽象类

每个子类都可以覆写override父类的方法
如果父类的方法没有实际意义，不能去掉方法的执行语句。否则就失去了多态的特性。
将父类的方法修饰为抽象方法abstract，所以父类也应该是抽象类。

public  abstract class People{
	public abstract void run(); //抽象方法没有任何执行语句
}

无法实例化一个抽象类，抽象类就是用来被继承，相当于定义一个规范，强制要求子类实现其定义的抽象方法。
如果不实现抽象方法，则该子类仍是一个抽象类。

八、接口

抽象方法本质是定义接口规范。
interface接口声明，接口不能定义实例字段。

public interface People{
	void run();
	double area();
}

implements实现接口，一个类可以实现多个接口。
如何希望子类不用继承的方法，可以使用default修饰。

public interface People{
	void run();
	default double area(){}
}

一般把公共逻辑放在abstract class中，接口层次代表抽象程度。

九、包和classpath-静态字段和方法

静态字段使用static修饰

public static String name;

普通字段在每个实例中都有自己独立的“空间”，而静态字段只有一个共享“空间”，所有实例都共享该字段。
通过类名·静态字段访问。不推荐通过实例变量访问静态字段。

静态方法使用static修饰

public static void run(){}

一般调用实例方法必须通过实例变量，静态方法不需要实例变量。通过类名·方法名访问。
静态方法不能访问this变量，不能访问实例字段，但是可以访问静态字段和静态方法。

十、包和classpath-包

package名字空间
包名+类名=完整类名
只要包名不同，类名就不同。同一个包下面不能存在同名的类。
包可以多层结构，包没有父子关系。
JVM加载class时加载完整类名。

通过import 导入包，使用完整类名，可以使用星号*，进行引用。

十一、包和classpath-作用域

访问权限是指在一个类的内部，能否引用另一个类以及访问它的字段和方法。
类、接口、字段和方法都可以设置访问权限，包括public、protected、private和package四种
内部类在类中创建类
局部变量在方法内部定义的变量，作用域在定义处开始到块结束。
在一个java文件中仅仅只有一个public class ，但是可以有多个非public class

十二、包和classpath-classpath和jar

运行：java -cp .jar 完整类名
classpath是一个环境变量**，指示JVM如何搜索class
jar包是zip格式的压缩文件，包含若干个.class文件（class前面的那个“.”代表的是当前目录）
使用jar包可以避免大量的目录和.class文件。
创建jar包可以通过JDK的jar命令，或者使用创建工具maven等，或者直接使用zip格式压缩。
JVM运行时自动加载JDK自带的class文件，打包在rt.jar中。

十三、java核心类-字符串和编码

String可以通过一个双引号“”创建，创建的内容不可变。
比较两个String内容是否相同

String s = "hello";
s.equals("Hello");//false
s.equalsIgnoreCase("Hello");//true  比较忽略字母大小写

在字符串中查找是否包含子串

String s = "hello";
s.contains("ll");//true
s.indexOf("ll");//2
s.startsWith("he");//true
s.endWith("lo");//true

String提供一个trim()方法，可以用于移除空白字符。

String s = "\t hello \r\n";
s = s.trim();//hello   返回一个新字符串

String提供一个substring()方法，提取子串。

String s = "hello world";
s.substring(7);//world
s.substring(1,5);//ello

字母大小写转换

String s = "Hello";
s.toUpperCase();//HELLO
s.toLowerCase();//hello

替换部分子串

String s = "hello";
s.replace("e","E");//hEllo
s.replaceAll("正则表达式,替换内容");

分割字符串

String s = "hello world";
String[]  ss = s.split(" ");//[hello,world] 返回的是一个字符串数组

拼接字符串

String[] s = {"hello","world"};
String ss = String.join("-",s);//hello-world

数据类型转换

String.valueOf("其他数据");//其他数据类型转换为String字符串,int,boolean,Object对象
Integer.parseInt("123");//123  Integer.valueOf("123")

String与Char[]相互转换

String s = "hello";
Char[] cs = s.toCharArray();//['h','e','l','l','o']   String内部不变，复制一份进行操作

String s2 = new String(cs);

String与byte[]相互转换

String s = "hello";
byte[] by = s.getBytes("UTF-8");

String ss = new String (by,"UTF-8");

编码ASCII
ASCII编码：计算机中存储的最小单元是字节，而一个英文字符占一个字节，最多表示128个字节。
字符‘A’的编码是0x41
GBK编码：一个中文字符需要两个字节，第一个字节的最高位为1。
Unicode编码：
UTF-8编码：容错能力强，英文版和ASCll是一致的。

JAVA使用的Unicode编码，运行时使用的也是Unicode编码，只需要在输入输出时考虑String与byte[]相互转换时，考虑编码问题。始终优先考虑UTF-8编码。

十四、java核心类-StringBuilder

字符串拼接，可以使用“+”号
如果在循环中拼接字符串，会创建新字符串对象，绝大部分为临时对象，浪费内存，影响GC效率。

String s = "";
for (int i = 0; i < 100; i++) {
     s = s + i;
}
System.out.println(s);

以使用StringBuilder进行有效拼接。
StringBuilder是可变对象，可以预分配缓冲区。

StringBuffer stringBuffer = new StringBuffer(1024);
for (int i = 0; i < 1000; i++) {
     stringBuffer.append(i);
}
System.out.println(stringBuffer.toString());

StringBuilder和StringBuffer接口完全相同
StringBuffer是StringBuilder的线程安全版本，在多线程中，建议使用StringBuffer。

链式操作就是return this 返回实例本身。

十五、java核心类-包装类型

数据类型：基本数据类型（int,float,boolean等）和引用类型（class类型）
基本类型不能够看出对象。

int n = null;//error

可以通过包装类型实现基本数据类型转为一个对象。
一般JDK为每种基本类型都创建了对应的包装类型

基本类型	对应的引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

Integer n = new Integer(99);
int i = n.intValue();//99

String类型转为int类型

Integer i = new Integer(99);
int a = Integer.parseInt("100");//100
String s = i.toString();//"99"

自动装箱和自动拆箱发生在编译阶段，会影响程序的执行效率。
包装类型定义了一些有用的静态变量
Boolean.TRUE Boolean.FALSE
Integer.MAX_VALUE Integer.MIN_VALUE
Long.SIZE Long.BYTES
==整数和浮点数包装类型继承自Number

Number num = new Integer(10);
byte b = num.byteValue();
int n =num.intValue();

十六、java核心类-JavaBean

满足以下命名规范的class称为JavaBean
private Type field 定义字段
public Type getField() 获取字段的值
public Type set Field() 设置字段的值

其中一组对应的getter和setter称为属性（property）。

十七、java核心类-枚举类

定义常量 static final 修饰
数值常量通过“==”进行比较
字符串常量通过“equals()”方法进行比较（equals()方法要区分大小写）。可以通过enum枚举类定义常量实现。

public enum Weekday{
	SUN,MON,TUE,WED,THU,FRI,SAT;
}
for(Weekday day:Weekday.values()){
	System.out.println(day);
}
Weekday fri = Weekday.FRI;

将enum类型转为String类型
String name = fri.name();
将String类型转为enum类型

Weekday fri = Weekday.valueOf("FRI");

十八、java核心类-常用工具类

Math类
常用方法
abs()/min()/max()
pow()/sqrt()/exp()/log()/log10()
sin()/cos()/tan()/asin()/acos()
常量
PI=3.1415926/E=2.71828
随机数
0<=Math.random()<1
Random类
生成伪随机数，给定一个种子，相同种子返回的随机数相同。
Random r = new Random();
r.nextInt()/r.nextLong()/r.nextFloat()/r.nextDouble()
生成一个不大于N的数
r.nextInt(N)
BigInteger
生成任意大小的整数，比较浪费时间
new BigInteger(“123456789…”);
BigDecimal
参考资料（BigDecimal）
生成任意精度的浮点数，比较浪费时间
new BigDecimal(“123.45678”);