C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。
JAVA是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。
面向过程注重的是过程,在整个过程中所涉及的行为,就是功能。
面向对象注重的是对象,也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来
类就是一类对象的统称。对象就是这一类具体化的一个实例。
类实例化
基本语法
// 创建类
class <class_name>{
field;//成员属性
method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();
class为定义类的关键字,ClassName为类的名字,{}中为类的主体。
类中的元素称为:成员属性。
类中的函数称为:成员方法。
示例:
class Person1{ //定义的类
public String name; //成员属性 实例变量
public int age;
public void eat(){ //实现的方法
System.out.println(name+"正在吃饭!");
}
public void sleep(){
System.out.println(name+"正在睡觉!");
}
public void print(){
System.out.println("我叫"+name+" 今年"+age+"岁了!");
}
}
提问: 为什么这里方法会没有用static来修饰?
解释: 被static修饰的方法属于类方法,可以通过类名.方法名直接引用,而不需要new出一个类来。
class Person{
public String name;
public int age;
public static int count; //静态成员变量 -> 类变量
public void eat(){
System.out.println(name+"正在吃饭!");
}
public void sleep(){
System.out.println(name+"正在睡觉!");
}
public void print(){
System.out.println("我叫"+name+" 今年"+age+"岁了!");
}
}
public class TestDemo {
public static void main(String[] args) {
Person person = new Person();
person.age++;
person.count++;
System.out.println(person.age);
System.out.println(person.count);
System.out.println("===========");
Person person1 = new Person();
person1.age++;
person1.count++;
System.out.println(person1.age);
System.out.println(person1.count);
}
static属于类名的,不依赖于对象,直接Person.count使用。
注意:
1.普通方法里不能定义静态变量
2.静态方法里也不能定义静态变量
3.普通方法内部可以调用静态方法
4.静态方法内部不能调用普通方法 (一定要用,就要new一个对象来调用了。)
难点问题:main函数为什么是静态的???
解答:首先,main函数是不是静态的都可以,这个东西取决于JVM。他自己设置成这样的就行。
注意,一个引用不能同时指向多个对象
引用不一定都在栈上
class Person{
public String name;
public int age;
public void eat(){
System.out.println(name+"正在吃饭!");
}
public void sleep(){
System.out.println(name+"正在睡觉!");
}
public void print(){
System.out.println("我叫"+name+" 今年"+age+"岁了!");
}
}
public class TestDemo {
public static void main(String[] args) {
Person person = new Person();//通过new实例化对象
person.name = "dabi"; //赋值
person.age = 20;
person.eat();//成员方法调用需要通过对象的引用调用
person.sleep();
person.print();
//产生对象 实例化对象
Person person2 = new Person();
Person person3 = new Person();
}
注意事项
new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建对个实例.
默认值规则
对于各种数字类型, 默认值为 0.
对于 boolean 类型, 默认值为 false.
对于引用类型(String, Array, 以及自定制类), 默认值为 null
一个对象 存储到哪里,和你是否被final修饰没关系
封装
private String name; //只能在当前类当中使用
要使用,用get获取,set改变
好处:属性更安全了 ,他不会暴露在类外了
快捷键:Alt + Insert
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public int getAge() {
// return age;
// }
//
// public void setAge(int age) {
// this.age = age;
// }
//
// public static void main5(String[] args) {
// Person person = new Person();
// //person.name = "bit";
// person.setName("bit");
// // person.age = 19;
// person.setAge(19);
// System.out.println(person.getName());
// System.out.println(person.getAge());
// }
构造方法
方法名和类名是相同的。且构造方法比较特殊,没有返回值。
构造方法是干嘛的? -> 一个对象的产生【对象的实例化】
1.为对象分配内存。
2.调用合适的构造方法。(构造方法不止一个)
// public Person(){
// this("chenman");//调用带有1个参数的构造方法
// System.out.println("Person()::不带参数的构造方法");
// }
//
// public Person(String name){
// this.name = name;
// System.out.println("Person(String)::带一个String类型参数的构造方法");
// }
//
// public Person(String name,int age){
// this.name = name;
// this.age = age;
// System.out.println("Person(String,age)::带两个‘一个String,一个age’类型参数的构造方法");
// }
注意1:
1.如果没有实现任何的构造方法,编译器会帮我们,默认生成一个不带参数的构造方法。也就是说,一个类,至少会有一个构造方法,不管你有没有写!!!
2.如果当前类有其他的构造方法,那么,编译器就不会帮我们生成不带参数的构造方法的。
3.构造方法 之间 可以构成重载
注意2:
this代表当前的对象 这个是错误的?
他代表的是当前对象的引用。
this
1.this.data 调用当前对象的属性
2.this.func() 调用当前对象的方法
3.this() 调用当前对象的其他的构造方法,必须放在第一行,只能存放在构造函数当中(先打印他)
代码块
本地代码块
实例代码块
静态代码块
同步代码块
{
// System.out.println("实例代码块");
// }
//
// static{
// count = 99;
// System.out.println("静态代码块");
// }
1.静态代码块最先执行,不管在前还是在后。
2.只会被执行一次。不用实例化对象也能被执行。
3.类加载的时候执行。
4.如果都是静态的,和定义的顺序有关系。
总结
这一章节确实有点绕,博主现在对他也不是特别的懂,写的知识点也都是零零散散的,希望大家多多指正。在这里感谢大家观看,让我们一起加油克服它,你的支持就是我最大的动力!!!