基本概念
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
面向过程：注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象：注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。
类和类的实例化
类就是一类对象的统称。对象就是这一类具体化的一个实例。类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。
用类类型创建对象的过程，称为类的实例化。实例化出的对象占用实际的物理空间，存储类成员变量，做个比方类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西。
// 创建类
class Person {
//成员属性 实例变量
public int age = 18; //字段
public String name = "张三";
public String sex = "男";
public void eat() {//成员方法
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
public void show() {
System.out.println("我叫" + name + ", " + sex + ", 今年" + age + "岁");
}
}
public static void main1(String[] args) {
Person person = new Person();//通过new实例化对象
person.eat();//成员方法调用需要通过对象的引用调用
person.sleep();
//产生对象 同一个类可以创建多个实例化对象
Person person2 = new Person();
Person person3 = new Person();
//访问字段
System.out.println(person.name);
System.out.println(person.age);
System.out.println(person.sex);
// 获取字符串长度
System.out.println(person.name.length());
//方法 用于描述一个对象的行为
person.show();
//show 方法是和 person 实例相关联的.
//如果创建了其他实例, 那么 show 的行为就会发生变化
person2.name = "李四";
person2.age = 20;
person2.show();
}
类的成员
类的成员可以包含以下：字段、方法、代码块、内部类和接口等。
在类中, 但是方法外部定义的变量。这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”(三种称呼都可以，一般不会严格区分)。
class Person {
public int age;//实例变量 存放在对象内
public String name;//实例变量
public String sex;//实例变量
public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
public static final int COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更
改
//实例成员函数
public void eat() {
int a = 10;//局部变量
System.out.println("eat()!");
}
//实例成员函数
public void sleep() {
System.out.println("sleep()!");
}
//静态成员函数
public static void staticTest(){
//不能访问非静态成员
//sex = "man"; error
System.out.println("StaticTest()");
}
}
public class Main{
public static void main(String[] args) {
//产生对象 实例化对象
Person person = new Person();//person为对象的引用
System.out.println(person.age);//默认值为0
System.out.println(person.name);//默认值为null
//System.out.println(person.count);//会有警告!
//正确访问方式：
System.out.println(Person.count);
System.out.println(Person.COUNT);
Person.staticTest();
//总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
person.eat();
person.sleep();
}
}
static关键字
a) 修饰属性，Java静态属性和类相关，和具体的实例无关。换句话说，同一个类的不同实例共用同一个静态属性。
b) 修饰方法，如果在任何方法上应用 static 关键字，此方法称为静态方法。
public static void main2(String[] args) {
Test t1 = new Test();
t1.a++;
Test.count++;
System.out.println(t1.a);
System.out.println(Test.count);
System.out.println("============");
//count被static所修饰，所有类共享。
Test t2 = new Test();
t2.a++;
Test.count++;
System.out.println(t2.a);
System.out.println(Test.count);
Test.change(); //无需创建实例对象 就可以调用
System.out.println(Test.count);
}
class Test{
public int a;
//修饰属性
public static int count;
//修饰方法
public static void change() {
count = 100;
//a = 10; error 不可以访问非静态数据成员
}
}
封装
private/ public 这两个关键字表示 “访问权限控制” 。
被 public 修饰的成员变量或者成员方法，可以直接被类的调用者使用。
被 private 修饰的成员变量或者成员方法，不能被类的调用者使用。
如果需要获取或者修改这个 private 属性，就需要使用 getter / setter 方法。
//封装
public static void main3(String[] args) {
Person2 person2 = new Person2();
System.out.println("我叫" + person2.name + ", 今年" + person2.age + "岁");
Person3 person3 = new Person3();
person3.show();
Person4 person4 = new Person4();
person4.setName("李四");
person4.setAge(18);
String name = person4.getName();
System.out.println(name);
person4.show();
}
//直接使用 public封装
class Person2 {
public String name = "张三";
public int age = 20;
}
//使用 private 封装属性, 并提供 public 方法供类的调用者使用.
class Person3 {
private String name = "张三";
private int age = 20;
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
//getter和setter方法
class Person4 {
private String name;//实例成员变量
private int age;
public void setName(String name){
//name = name;//不能这样写
this.name = name;//this引用，表示调用该方法的对象
}
public String getName(){
return name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
构造方法
构造方法是一种特殊方法，使用关键字new实例化新对象时会被自动调用，用于完成初始化操作。
//构造函数
class Person5 {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person5() {
this.name = "caocao";
this.age = 10;
this.sex = "男";
}
//带有3个参数的构造函数
public Person5(String name,int age,String sex) {
//this关键字
this.name = name;
this.age = age;
this.sex = sex;
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public static void main4(String[] args) {
Person5 p1 = new Person5();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
p1.show();
Person5 p2 = new Person5("zhangfei",80,"男");//调用带有3个参数的构造函数
p2.show();
}
代码块
使用 {} 定义的一段代码。
public static void main5(String[] args) {
Person6 p1 = new Person6();
Person6 p2 = new Person6();
}
//代码块
class Person6{
private String name;//实例成员变量
private int age;
private String sex;
private static int count = 0;//静态成员变量 由类共享数据 方法区
public Person6(){
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "zhangsan";
this.age = 18;
this.sex = "man";
System.out.println("I am instance init()!");
}
//静态代码块
static {
count = 10;//只能访问静态数据成员
System.out.println("I am static init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
匿名对象
没有引用的对象称为匿名对象，匿名对象只能在创建对象时使用，如果一个对象只是用一次，后面不需要用了，可以考虑使用匿名对象。
//匿名对象
class Person7 {
private String name;
private int age;
public Person7(String name,int age) {
this.age = age;
this.name = name;
}
public void show() {
System.out.println("name:"+name+" " + "age:"+age);
}
}
public static void main(String[] args) {
new Person7("caocao",19).show();//通过匿名对象调用方法
}
