1、类
创建类
public class Computer {
//修饰符public：类可以被任意访问
//类的正文都要用{}括起来
//属性：颜色、尺寸、内存、CPU
String color;
double size;
int memory;
String cpu;
//方法：开机、关机、显示电脑配置
public void start() {
System.out.println("开机...");
}
public void close() {
System.out.println("关机");
}
public void display() {
System.out.println("颜色：" + color + "，尺寸：" + size + "，内存：" + memory + "，CPU：" + cpu); }
}
public class Person {
//属性：姓名、年龄、性别、身高、体重
String name;
int age;
String sex;
double height;
double weight;
//方法：走路、吃饭、睡觉、工作、显示个人信息
public void walk() {
System.out.println("走路。。。");
}
public void display() {
System.out.println(""); }
}
创建对象（也叫类的实例化）
public class Test {
public static void main(String[] args) {
//创建对象（类的实例化）：声明（数据类型 变量名）、分配空间（同时为属性赋默认值）、赋值（可选，因为有默认值） Computer c1 = new Computer();
c1.color = "red";
c1.size = 15.6;
c1.cpu = "i7";
c1.memory = 8;
c1.display();
Computer c2 = new Computer();
c2.color = "black";
c2.display();
Person p1 = new Person();
p1.name = "jack";
p1.age = 12;
p1.height = 1.5;
p1.display();
}
}
面向对象3大特征：封装、继承、多态
1、封装
//储值卡
public class CashCard {
String number;//卡号
int balance;//余额
int bonus;//红利点数，单次充值大于等于1000得1点
public CashCard(String n,int ba,int bo) {//自己定义的构造器，默认的构造器不提供了
number = n;
balance = ba;
bonus = bo;
}
}
构造函数名称是与类名同名，不用声明返回类型
public class Test {
public static void main(String[] args) {
CashCard card1 = new CashCard("A001", 500, 0);
CashCard card2 = new CashCard("A002", 300, 0);
CashCard card3 = new CashCard("A003", 1000, 1);
CashCard card4 = new CashCard("A004", 2000, 2);
CashCard card5 = new CashCard("A005", 3000, 3); } }
2、继承
继承定义： 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。 此处的多个类称为子类，单独的这个类称为父类（基类或超类）
类继承语法：class Subclass extends Superclass{ }
说明：
子类继承了父类，就继承了父类的方法和属性。
子类也可以创建新的属性和方法。
子类不是父类的子集，而是对父类的“扩展”。
Java中的类只支持单继承，不允许多重继承；
一个子类只能有一个父类；
一个父类可以派生出多个子类；
子父类是相对的概念
class SubDemo extends Demo1,Demo2...//是错误 的
3、多态
多态性，可以理解为一个事物的多种表型形态。
在Java中有两种体现：①方法的重载与重写；②对象的多态性
public class Test2 {
public static void main(String[] args) {
Person s = new Student();//父类的声明，子类的实现
}
}
1、类的成员1：
属性 属性=变量=field
1）变量的分类：
按照数据类型的不同：基本数据类型和引用数据类型
按照声明的位置不同：成员变量和局部变量
成员变量：在方法体外，类体内声明的变量称为成员变量
局部变量：在方法体内部声明的变量称为局部变量
2）成员变量语法格式： 修饰符 类型 属性名 = 初值;
修饰符public：该属性可以被该类以外的方法访问
类型：8种基本数据类型和引用类型任一都可以
3）成员变量初始化值（或者叫默认值） 当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。 除了基本数据类型之外的变量类型都是引用类型，如上面的Person及数组。
总结：对象的成员变量和数组元素都有初始化值，基本数据类型变量没有初始化值
成员变量类型 初始值
byte 0
short 0
int 0
long 0
float 0.0
double 0.0
char 空格
boolean false
引用类型 null
2、类的成员2：方法
函数=方法=method
语法格式： 修饰符 返回值类型 方法名( 参数类型 形参1,参数类型 形参2,….) {
方法体语句；
}
说明： ①修饰符：public、private、protected、缺省 ②返回值类型：8种基本数据类型和引用类型任一都可以 ③return作用： 返回方法指定类型的值（这个值总是确定的） 结束方法的执行（仅仅一个return语句）
④return和void演示
public class TestVoidReturn {
/*
* 返回值类型为String
* return + 返回值 表示方法返回数据，数据类型和方法返回值类型一致 */
public String test2() {
return "test2()方法";
}
public int test3() {
return 3;
}
/*
* void无返回值
*/ public void test1() {
System.out.println("test1()方法");
return; //此处return可以省略 }
/*
* break跳出循环
* continue跳出本次循环，进入下一次循环
* return返回方法指定类型的值、结束方法的执行
*/
public void test11() {
for(int i = 1; i <= 5; i++) {
if(i == 3) {
return;
}
System.out.println(i);
}
}
public static void main(String[] args) {
TestVoidReturn test = new TestVoidReturn();
test.test1();
String str = test.test2();
System.out.println(str);
int i = test.test3();
System.out.println(i);
test.test11();
System.out.println("main方法");
} }
⑤参数
参数类型：就是该形式参数的数据类型。
形参：即形式参数，方法声明时，方法小括号内的参数
实参：调用方法时，实际传给形参的参数值
public class TestArgs {
//形参是基本数据类型
public void m1(int a) {//a是形参 a=1
a = 2;
System.out.println("m1()方法中的a=" + a);
public static void main(String[] args) {
TestArgs test = new TestArgs();
test.m1(1);//1是实参
int a = 1;
test.m1(a);//a是实参
方法的重载
1）要求
在同一个类中 方法名必须相同 ；方法的参数列表不同（①参数的个数不同②参数的类型不同）
注意：方法的重载与方法的返回值类型无关
public class TestOverload {
//返回两个整数的和
public int add(int x, int y) {
return x + y; }
//返回三个整数的和
public int add(int x, int y, int z) {
return x + y + z; }
//返回两个浮点数的和
public double add(double x, double y) {
System.out.println("aaa"); return x + y; }
//返回三个浮点数的和
public double add(double x, double y, double z) {
return x + y + z;
}
2）不能构成重载的情形
参数名称不同，不能构成重载
public int add(int x,int y){return x+y;}
public int add(int y,int x){return x+y;}
方法名称不同，不能构成重载
public int add(int x,int y){return x+y;}
public int add2(int x,int y,int z){return x+y+z;}
返回值类型不同，不能构成重载
public int add(int x,int y){return x+y;}
public void add(int x,int y){System.out.println(x+y);
方法的重写
前提：有子类继承父类 ，子类继承父类以后，若父类的方法对子类不适用， 那么子类可以对父类的方法重写(override overwrite)、覆盖、覆写。
public class Person {//类
public String name;//属性
public void info() {//方法
System.out.println("姓名：" + name);
}
}
public class Student extends Person {
private String course;
private String school;
//重写
public void info() {
System.out.println("姓名：" + name + "，课程：" + course + "，学校：" + school); }
//重载(注意：区分重写和重载)
public void info(int i) {
}
}
3、类的成员3：构造器
构造器作用：创建对象、给创建的对象的属性赋值（又叫初始化） 若不显示声明类的构造器的话，程序会默认提供一个空参的构造器，默认构造器的修饰符与所属类的修饰符一致 ，每个类都至少有一个构造器
编写一个例子，体现封装、继承和多态
public class Person{
public void test() {
}
}
public class Student extends Person {//继承
private String name;//封装
@Override
public void test()
{ System.out.println("1、多态：重写");
}
public void test(String x) {//2、多态：重载
System.out.println(x);
}
public static void main(String[] args) {
Person p = new Student();//3、多态：父类的声明，子类的实现
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
