二、变量
定义：
- 1.变量是程序中最基础的存储单元，其要素包括变量名、变量类型和作用域；
- 2.变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须先申请（声明），然后必须进行赋值（填充内容），才能使用；
分类：
- 1.按声明的位置划分：
1）、局部变量（方法体外，类体内）；2）、成员变量（方法体内部）
- 2.变量类型：
基本类型和引用类型
- 3.局部变量和成员变量的区别：
成员变量不用初始化，Java会默认初始化，而局部变量不行
三、面向对象
- 面向对象思维：
1、考虑的是有哪些类哪些对象；2、这些类和这些对象，应该具有哪些属性和方法;3、类和类之间的关系
- 类和对象的关系：
1、关联关系；2、继承关系；3、聚合关系；4、实现关系；5、多态
3.1.类的定义
1.类的组成：成员变量和方法
2.对象的创建和使用
2.1、new创建对象
2.2、使用对象(引用).成员变量或引用对象的成员变量
2.3、使用对象(引用).方法(参数列表)来调用对象的方法
2.4、同一类的每个对象有不同的成员变量存储空间
2.5、同一类的每个对象共享该类的方法。
3.2.类的对象的关系
3.3.构造方法（构造函数）
1. 使用new+构造方法，创建一个新的对象
2. 构造函数是定义在Java类中的一个用来初始化对象的函数；
3. 构造函数与类同名且没有返回值；
4. 当你创建一个类时，如果不写构造方法，系统会默认给一个参数和方法休都为空的构造方法，如果你自己写的构造方法，系统就不会再有默认的构造方法
public class GouZaofunction {
public static void main(String[] args) {
// TODO Auto-generated method stub
Persion tom = new Persion(18, "tom");//这里new一个对象的时候，其实就是调用它的构造方法来new；
System.out.println(tom.name);
}
}
class Persion {
int age;
String name;
//下面是构造方法
public Persion(int _age,String _name) {
age = _age;
name = _name;
}
//如果没有上面的构造方法时，系统会默认的创建一个Persion(){}
}
3.4.方法重载
一个类中可以定义有相同名字，但参数不同的多个方法。调用时，会根据不同的参数选择对应的方法。
构造方法的重载，跟普通方法一样
public class TestOverLoad {
public static void main(String[] args) {
// TODO Auto-generated method stub
Persion tom = new Persion(18, "tom");
Persion ken = new Persion("ken");//这是在调用重载的构造方法
System.out.println(tom.name);
}
}
class Persion {
int age;
String name;
//下面是构造方法
public Persion() {
// TODO Auto-generated constructor stub
}
//下面是构造方法重载
public Persion(String _name) {
name = _name;
}
public Persion(int _age,String _name) {
age = _age;
name = _name;
}
}
3.5.this关键字
1. 在类的方法定义中使用的this关键字代表使用该方法的对象的引用
2. 当必须指出当前使用方法的对象是谁时要使用this；
3. 有时使用this可以处理方法中成员变量和参数重名的情况；
4. this可以看作是一个变量，它的值是当前对象的引用
public class TishTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Leaf leaf = new Leaf(100);
leaf.increament().increament().print();
}
}
class Leaf {
int i=0;
public Leaf(int i) {
// TODO Auto-generated constructor stub
this.i = i;
}
Leaf increament(){
i++;
return this;
}
void print(){System.out.println(("i="+i));}
}
3.6.static关键字
1. 在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份
2. 用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。
3. 可以通过对象引用或类名（不需要实例化）访问静态成员
public class CatStatic {
private static int sid; //很明显一般做计数用
private int id;
private String name;
public CatStatic(String name) {
// TODO Auto-generated constructor stub
this.name = name;
id = sid ++;
}
public void info() {
System.out.println("My name is"+name+"NO.:"+id);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
sid = 100;//直接用，不用创建对象后再用
CatStatic mini = new CatStatic("mini");
CatStatic pipi = new CatStatic("pipi");
mini.info();
pipi.info();
}
}
3.7.访问控制和类的继承
1. Java权限修饰符public protected private 置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限。
2. 对于class的权限修饰只可以用public和default
1).public类可以在任意地方被访问
2).default类只可以被同一个包内部的类访问
1. java中使用extends关键字实现类的继承机制，语法规则：<modifier>class<name>[extends<superclass>]{... ...}
2. 通过继承，子类自动拥有父类(superclass)的所有成员(成员变量和方法)
3. Java只支持单继承，不允许多继承
//继承的权限控制
class Parent{
private int n_private = 1;
int n_default = 2;
protected int n_protected = 3;
public int n_public = 4;
}
class Child extends Parent {
public void f(){
n_private = 100 //会报错，父母的成员变量虽然可以继承，但不能访问，private只能自己类本身来访问
n_default = 200 //正常，下面的几个都是正常
}
}
3.8.方法的重写
1. 重写是对子类来说，对父类的方法进行重写
2. 重写方法必须和被重写的方法名称、参数、返回类型都相同
3. 重写方法不能使用比被重写方法更严格的访问权限
public class ExtendsTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person person = new Person();
person.setAge(18);
person.setName("tom");
person.getInfo();
Child child = new Child();
child.setName("jam");
child.setAge(19);
child.setSchool("中山大学");
child.getInfo();
}
}
class Person{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String _name) {
name = _name;
}
public int getAge() {
return age;
}
public void setAge(int _age) {
age = _age;
}
void getInfo(){
System.out.println("Name is "+ name+"\n"+"age is "+age);
}
}
class Child extends Person {
private String school;
public String getSchool() {
return school;
}
public void setSchool(String _school) {
school = _school;
}
void getInfo(){
System.out.println("Name is "+getName()+"\n"+"age is "+getAge() +"\n"+"school is "+getSchool());
}
}
3.9.super关键字
super关键字，是在继承里面，指的是父类对象的引用
public class SuperTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildClass child = new ChildClass();
child.f();
}
}
class FartherClass{
public int value;
public void f() {
value = 100;
System.out.println("Farther's value is "+ value);
}
}
class ChildClass extends FartherClass{
public int value;
public void f() {
super.f();//执行的是父类的方法
value = 200;//对子类的value赋值
System.out.println("Child's value is "+ value);
System.out.println(value);//子类的value
System.out.println(super.value);//父类的value
}
}
3.10.继承中的构造方法
1. 子类的构造方法必须调用其父类的构造方法
2. 子类可以在自己的构造方法中使用super(argument_list)调用其父类的构造方法
2.1.使用this(argument_list)调用本类的另外的构造方法
2.2.使用super，必须写在子类构造方法的第一行
3. 如果子类的构造方法中没有显式的调用父类的构造方法，则系统默认调用父类的无参数的构造方法
4. 如果子类既无显式调用父类的构造方法，而父类又没有无参数的构造方法，则编译出错
3.11.多态
1. 定义：是指在执行期间（非编译期）判断所引用对象的实际类型，根据其实际类型调用其相应的方法
2. 必要条件：2.1）.要有继承 ；2.2）.要有重写；
2.3）.父类引用指向子类对象
public class Test {
public static void main(String[] args) {
Animal a = new Animal("a");
lady l1 = new lady("li",a);
Cat c = new Cat("c","blue");
Dog d = new Dog("d", "yellow");
//动态的，根据程序运行时，传的什么来决定运行哪个方法
l1.myenjoy(a);//叫声%%%%%%%%%%%%%
l1.myenjoy(c);//猫叫声.......
l1.myenjoy(d);//狗叫声！！！！！！！！！！
}
}
class lady {
private String name;
private Animal pet;
public lady(String name,Animal pet) {
// TODO Auto-generated constructor stub
this.name = name;
this.pet = pet;
}
public void myenjoy(Animal a) {
a.enjoy();
}
}
class Animal {
private String name;
public Animal(String name) {
// TODO Auto-generated constructor stub
this.name = name;
}
public void enjoy() {
System.out.println("叫声%%%%%%%%%%%%%");
}
}
class Cat extends Animal {
private String eyesColor;
public Cat(String name,String eyesColor) {
super(name);
this.eyesColor = eyesColor;
// TODO Auto-generated constructor stub
}
public void enjoy() {
System.out.println("猫叫声.......");
}
}
class Dog extends Animal {
private String color;
public Dog(String name,String color){
super(name);
this.color = color;
}
public void enjoy() {
System.out.println("狗叫声！！！！！！！！！！");
}
}
3.12.final关键字
1. final的变量的值不能被改变
2. final的方法不能被重写
3. final的类不能被继续
四、异常
1. 程序运行期间发生的一些错误事件，用try..catch去捕获
2. 异常分类，根异常Trowable 下面分两种Erro(不能处理)和Exception（能处理），Exception再分两种，RuntimeException和其它，RuntimeException可以不处理，但除了这个其它的都要处理
public class TestEx {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("异常的catch。。。。");
try {
System.out.println(2/0);
} catch (Exception e) {
// TODO: handle exception
System.out.println("系统出错了！");
e.printStackTrace();
}
}
}
五、数组
- 一维数组二维数组多维数组
public class TestArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
Date[] days = new Date[3];
for (int i = 0; i < days.length; i++) {
days[i] = new Date(2017, 6, i);
days[i].pintDate();
}
}
}
class Date{
private int year,month,day;
public Date(int y,int m,int d) {
// TODO Auto-generated constructor stub
year = y;
month = m;
day = d;
}
public int getDay() {
return day;
}
public int getMonth() {
return month;
}
public int getYear() {
return year;
}
public void pintDate() {
System.out.println("日期是："+getYear()+"-"+getMonth()+"-"+getDay());
}
}
