Java类定义和四大属性
- Java类成分
- 面向对象思想概述
- 类的五大成分
- 类的构造器
- 封装
- this关键字
- static关键字
- 成员变量的分类和访问
- 继承(extends)
Java类成分
面向对象思想概述
Java是一种面向对象的高级编程语言。
面向对象：是用代码去高度模拟现实世界的事物，从而让软件为任 务处理业务，为人类服务。
高级语言：代码看起来很像人类的自然语言。
面向对象最重要的两个概念：类和对象。
类是相同事物共同特征的描述。类只是学术上的一个概念并非真实存在的，只能描述一类事物。
对象：是真实存在的实例。 实例==对象。
结论：有了类和对象就可以描述万千世界所有的事物。必须先有类才能有对象。
定义类：
格式：修饰符 class 类名{
}
注意：
1.类名的首字母建议大写。满足驼峰式.StudentNameCode。
2.一个Java代码文件中可以定义多个类。但是按照规范还是建议一个Java文件定义一个类。
3.一个Java代码文件中，只能有一个类是用public修饰的，而且public修饰的类名必须成为当前Java代码的文件名称。
类的五大成分
类中的成分:有且仅有五大成分（五大金刚）
修饰符 class 类名{
// 1.成员变量(Field): 描述类或者对象的属性信息的。
// 2.成员方法(Method): 描述类或者对象的行为信息的。
// 3.构造器(Constructor): 初始化一个对象返回引用。
// 4.代码块(后面介绍)
// 5.内部类(后面介绍)
}
类中有且仅有这五种成分，否则代码报错！
注意：只要不是这5大成分放在类下就会报错
public class ClassDemo {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("铁扇公主");
System.out.println(s1.getName());
Student s2 = new Student("铁扇公主");
System.out.println(s2.getName());
}
}
class Student{
private String name ;
public Student(){
}
public Student(String name){
this.name = name ;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Animal01{
}
类的构造器
格式：修饰符 类名(形参列表){
}
作用：初始化类的一个对象返回。
构造器的分类：无参数构造器，有参数构造器。
构造器的注意点：一个类默认自带一个无参数构造器，但是如果写了有参数构造器那么
默认的无参数构造器就消失了，此时如果还需要用无参数构造器就需要自己从新写一个。
构造器初始化对象的格式：
类名 对象名称 = new 构造器;
Student s = new Student();
无参数构造器的作用：初始化一个类的对象（使用对象的默认值初始化）返回。
有参数构造器的作用：初始化一个类的对象（可以在初始化对象的时候为对象赋值）返回。
注意：一个类默认会自带一个无参数构造器，即使不写它也存在，但是如果一个类
它写了一个构造器，那么默认的无参数构造器就被覆盖了!!
封装
面向对象的三大特征：封装，继承，多态。
是Java语言的风格。是我们在开发中必须遵循的，即使毫无意义，代码还是要按照这个风格写！！
封装的作用：
- 可以提高安全性。
- 可以实现代码的组件化。
封装的规范：
- 建议成员变量都私有：用private修饰。
private修饰的方法，成员变量，构造器等只能在本类被直接访问。 - 提供成套的getter+setter方法暴露成员变量的取值和赋值。
public修饰符，是公开的意义。
小结：
封装的核心思想：合理隐藏，合理暴露。
封装已经成为Java代码的风格，即使代码毫无意义，还是要按照封装的规范写代码。
成员变量私有，提供getter+setter方法。
this关键字
this关键字的作用：
- this代表了当前对象的引用。
- this关键字可以用在实例方法和构造器中。
- this用在方法中，谁调用这个方法，this就代表谁。
- this用在构造器，代表了构造器正在初始化的那个对象的引用。
package com.itheima._01知识回顾;
public class ThisDemo02 {
public static void main(String[] args) {
Animal a1 = new Animal();
a1.setName("金毛");
System.out.println(a1.getName());
Animal a2 = new Animal("泰迪",3,'公');
System.out.println(a2.getName());
}
}
class Animal{
private String name;
private int age ;
private char sex ;
public Animal() {
}
public Animal(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
static关键字
引入：
我们之前定义了很多成员变量（name , age , sex）其实我们只写了一份，但是发现每个对象都可以用，就说明Java中这些成员变量或者方法是存在所属性的。
有些是属于对象的，有些是属于类本身的。
Java是通过成员变量是否有static修饰来区分是类的还是属于对象的
static = = 静态 = = 修饰的成员（方法和成员变量）属于类本身的。
按照有无static修饰，成员变量和方法可以分为：
成员变量：
- 静态成员变量（类变量）
有static修饰的成员变量称为静态成员变量也叫类变量，属于类本身的，直接用类名访问即可。 - 实例成员变量
无static修饰的成员变量称为实例成员变量，属于类的每个对象的，必须用类的对象来访问。
成员方法：
- 静态方法
有static修饰的成员方法称为静态方法也叫类方法，属于类本身的，直接用类名访问即可。 - 实例方法
无static修饰的成员方法称为实例方法，属于类的每个对象的，必须用类的对象来访问。
小结：
- 有static修饰的属于类叫静态成员变量，与类一起加载一次，直接用类名调用即可。
- 无static修饰的属于类的每个对象的叫实例成员变量，与类的对象一起加载，对象有多少个，实例成员变量就加载多少份。必须用类的对象调用。
- 有static修饰的属于类叫静态方法，直接用类名调用即可。
- 无static修饰的属于类的每个对象的叫实例方法，必须用类的对象调用。
成员变量的分类和访问
按照有无static修饰成员变量分为：
（1）静态成员变量：有static修饰，属于类本身与类一起加载一次，直接用类名访问即可。
（2）实例成员变量：无static修饰，属于类的每个对象的，必须先创建对象，再用对象来访问。
成员变量的访问语法：
- 静态成员变量访问：
类名.静态成员变量
对象.静态成员变量。（不推荐） - 实例成员变量的访问：
对象.实例成员变量。
小结：
静态成员变量有static修饰，属于类本身，与类加载一次，因为只有一份所以可以被类和类的对象共享访问。
注意：不建议用对象访问静态成员变量，静态成员变量直接用类名访问即可！！！
实例成员变量，无static修饰，属于类的对象的，必须先创建对象，然后用对象来访问！
public class Student{
public static String schoolName = "黑马";
private String name;
private int age ;
public static void main(String[] args) {
System.out.println(Student.schoolName);
System.out.println(schoolName);
Student swk = new Student();
swk.name = "孙悟空";
System.out.println(swk.name);
System.out.println(swk.age);
System.out.println(swk.schoolName);
}
}
public class Student {
private String name;
private int age ;
public static void inAddr(){
System.out.println("我们都在天河区吉山村happy的学习Java!");
}
public void eat(){
System.out.println(name + "已经"+age+"岁，在吃好吃的！！");
}
public static void main(String[] args) {
Student.inAddr();
inAddr();
Student zbj = new Student();
zbj.name = "猪刚鬣";
zbj.age = 1000;
zbj.eat();
zbj.inAddr();
}
}
拓展(面试常考)
方法：实例方法，静态方法。
成员变量：实例成员变量，静态成员变量。
8种访问形式的问答：
- 实例方法是否可以直接访问实例成员变量？可以的，因为它们都属于对象。
- 实例方法是否可以直接访问静态成员变量？可以的，静态成员变量可以被共享访问。
- 实例方法是否可以直接访问实例方法? 可以的，实例方法和实例方法都属于对象。
- 实例方法是否可以直接访问静态方法？可以的，静态方法可以被共享访问！
-------------------------------------------------------------------- - 静态方法是否可以直接访问实例变量？ 不可以的，实例变量必须用对象访问！！
- 静态方法是否可以直接访问静态变量？ 可以的，静态成员变量可以被共享访问。
- 静态方法是否可以直接访问实例方法? 不可以的，实例方法必须用对象访问！！
- 静态方法是否可以直接访问静态方法？可以的，静态方法可以被共享访问！！
public class MethodFieldDemo {
public static String schoolName = "黑马";
private String name;
public static void test(){
}
public void run(){
}
public void eat(){
run();
test();
System.out.println(name);
System.out.println(schoolName);
}
}
继承(extends)
概述
继承是Java中一般到特殊的关系，是一种子类到父类的关系。
例如：学生类继承了人类。 猫类继承了动物类。
被继承的类称为：父类/超类。
继承父类的类称为：子类。
作用
“可以提高代码的复用”，相同代码可以定义在父类中。
然后子类直接继承父类，就可以直接使用父类的这些代码了。
（相同代码重复利用）
特点
子类继承了一个父类，子类就可以直接得到父类的属性（成员变量）和行为（方法）了。
格式
子类 extends 父类{
}
小结:
继承是子类到到父类的一种关系。
子类继承了一个父类，子类就可以直接得到父类的属性和行为了。
在Java中继承是 “is a” 的关系。Cat extends Animal：猫是一个动物。
在Java中，子类是更强大的，子类不仅继承了父类的功能，自己还可以定义自己的功能。
public class ExtendsDemo {
}
class Animal{
}
class Cat extends Animal{
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
