1.面向对象概述
我们学习编程语言最终目的是用程序去模拟现实生活中的事物，让事物与事物之间产生关系，然后模拟现实生活中的场景。
属性：就是对事物的描述 -------成员变量
行为：就是事物能够做什么事情 -------成员方法
成员变量：在类中方法外定义的变量都叫成员变量语句定义格式：修饰符 数据类型 变量名;
成员方法：在类中定义
定义的格式与我们在学习是规范的定义语法是一样：
修饰符 返回值类型 方法名(参数类型1 参数名1,....){
方法体;
return xxx;
}
注意：现在开始将static去掉！！！！
通过类去创建对象
//语句定义格式：
//类名 对象名 = new 类名();
//根据Person类创建一个人对象 Person p1=new Person();
对象内存图
class Student {
//成员变量
String name;
// int age;
private int age;
public int getAge() {
return age;
}
public void setAge(int a) {
if (a > 0 & a < 100) {
age = a;
} else {
System.out.println("========================");
System.out.println("=======年龄有误！！=======");
System.out.println("========================");
}
}
//成员方法
public void study() {
System.out.println("学习");
}
public void eat() {
System.out.println("吃饭");
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建一个学生对象
Student s1 = new Student();
//给成员变量进行赋值
s1.name = "reynolds";
s1.setAge(18);
System.out.println("姓名：" + s1.name + ", 年龄：" + s1.getAge());
}
}2.成员变量与 局部变量的区别
在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
匿名对象：就是没有名字的对象。 是对象的一种简化表示形式
匿名对象的两种使用情况 1.对象调用方法仅仅一次的时候 2.作为实际参数传递
例：new Demo2().fun2(new Demo())
3.三大特征
3.1 封装
3.1.1封装概述
概念：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
隐藏实现细节，提供公共的访问方式 提高了代码的复用性 提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起来。 把属性隐藏，提供公共方法对其访问。
3.1.2 private关键字
private关键字： 是一个权限修饰符。 可以修饰成员(成员变量和成员方法) 被private修饰的成员只在本类中才能访问。private最常见的应用： 把成员变量用private修饰 提供对应的getXxx()/setXxx()方法 一个标准的案例的使用
x
//对于同一个文件夹下的类，类名不能重复
class Student2 {
//成员变量
private String name;
private int age;
public void setName(String s) {
name = s;
}
public String getName() {
return name;
}
public void setAge(int i) {
age = i;
}
public int getAge() {
return age;
}
//打印所有的成员变量值
public void show() {
System.out.println("姓名：" + name + ",年龄：" + age);
}
}
public class StudentDemo2 {
public static void main(String[] args) {
//创建一个学生对象
Student2 s1 = new Student2();
// s1.name=
s1.setName("reynolds");
s1.setAge(18);
String name = s1.getName();
int age = s1.getAge();
System.out.println("姓名：" + name + ",年龄：" + age);
System.out.println("=========================================");
s1.show();
}
}3.1.3 this关键字
this:代表所在类的对象引用 记住： 方法被哪个对象调用，this就代表那个对象
什么时候使用this呢? 局部变量隐藏成员变量
变量使用的就近原则：先在本方法中找，如果找不到再去成员变量中去找
class Student3{
//成员变量
private String name;
private int age;
public void setName(String name) { //String name = "刘璇"
//变量使用遵循：就近原则
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
//打印所有的成员变量值
public void show() {
this.fun();
System.out.println("姓名：" + this.name + ",年龄：" + this.age);
}
public void fun(){
System.out.println("今天天气不错！！");
}
private void fun2(){
System.out.println("这是被private修饰fun2方法");
}
public void fun3(){
fun2();
}
}
public class StudentDemo3 {
public static void main(String[] args) {
//创建一个学生对象
Student3 s1 = new Student3();
// s1.name=
s1.setName("reynolds");
s1.setAge(18);
String name = s1.getName();
int age = s1.getAge();
System.out.println("姓名：" + name + ",年龄：" + age);
System.out.println("=========================================");
s1.show();
// s1.fun2();
s1.fun3();
}
}3.1.4 构造方法
作用：给对象的数据进行初始化
语句定义格式
1）构造方法的方法名与类名一致
2）没有返回值，连void都不能出现
构造方法注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供，最好俩个有参无参都定义一下
构造方法也是可以重载的
Student() {
System.out.println("=============你好=============");
}
Student(String name, int age) {
// System.out.println("这是重载的方法"+s);
this.name = name;
this.age = age;
}
使用alt+insert快捷键可以快速写构造方法和get，set方法
实例：
//以面向对象的思想，编写自定义类描述图书信息。设定属性包括：书名，作者，出 版社名，价格；方法包括：信息介绍 show()
//要求：
//1)设置属性的私有访问权限，通过公有的 get,set 方法实现对属性的访问
//2)限定价格必须大于 10，如果无效进行提示
//3)限定作者，书名为只读属性
//4)设计构造方法实现对属性赋值
//5)信息介绍方法描述图书所有信息
//编写测试类，测试图书类的对象及相关方法（测试数据信息自定）
class Book{
String bname;
String author;
String press;
int price;
public Book(String bname, String author, String press, int price) {
this.bname = bname;
this.author = author;
this.press = press;
if(price>10){
this.price = price;
}else{
System.out.println("价格无效");
}
}
public void setPrice(int price) {
this.price = price;
}
public void setBname(String bname) {
this.bname = bname;
}
public String getBname() {
return bname;
}
public String getAuthor() {
return author;
}
public String getPress() {
return press;
}
public int getPrice() {
return price;
}
public void show(){
System.out.println("书名："+bname+"\n作者："+author+"\n出版社："+press+"\n价格："+price);
}
}
public class Booktest {
public static void main(String[] args) {
Book b1=new Book("鹿鼎记","金庸","人民文学出版社",55);
b1.show();
System.out.println("-------------------------------------");
Book b2=new Book(" ","古龙","人民文学出版社",55);
b2.setBname("绝代双骄");
b2.setPrice(100);
b2.show();
}
}类的初始化过程
3.1.5 static关键字
可以修饰成员变量和成员方法
java中将所有对象共享的成员，使用一个关键字进行修饰：static(静态的)
static关键字特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享 这也是我们判断是否使用静态关键字的条件
可以通过类名调用
static的使用
1、可以修饰成员变量，成员方法
2、被static修饰的成员，属于类成员（静态成员），可以使用类名.的方式直接调用，不需要创建对象
3、静态的成员方法只能访问静态的成员(包括成员变量，成员方法)
4、非静态的成员方法既可以访问静态的成员，也可以访问非静态的成员
5、static不能修饰构造方法
6、被static修饰的成员方法中不允许出现this关键字， 因为被static修饰成员是属于类本身是优先于对象而存在的，但是呢this关键字代表的是当前对象，所以两者意思上冲突了。
静态区的使用
解释main方法的每一个单词
//public是公共的意思，指最大权限，因为main方法是由JVM所调用，所以权限一定要够大
//static，静态的意思，也就意味着不需要创建对象就可以被调用起来
//void：表示没有返回值的意思，因为main方法是由JVM所调用，给了返回值其实给的是JVM，没有意义
//main：方法的名字，定死的
//String[] args:方法的参数列表，是一个一维数组，元素类型是String类型的
3.1.6 制作帮助文档
写法实例：
package com.shujia.wyh.day06;
/**
*
* 这个类是专门对数组做操作的类，封装了比如打印数组、获取最大值等等方法，后续持续更新....
* @author xiaohu
* @version 1.0
*
*/
public class ArrayTool {
private ArrayTool(){
}
/**
* 这个方法是获取int类型的一维数组中的最大值
* @param arr arr是一维数组，元素是int类型的，参数的名字叫做arr
* @return 返回值是int类型的元素，返回的是数组中的最大值
*/
public static int getMaxNumber(int[] arr) {
int maxNum = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > maxNum) {
maxNum = arr[i];
}
}
return maxNum;
}
/**
* 这个方法用作以指定的输出格式打印int类型一维数组
* 输出的格式为：[元素1,元素2,...]
* @param arr arr是一维数组，元素是int类型的，参数的名字叫做arr
*/
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if (i == 0) {
System.out.print("[" + arr[i] + ",");
} else if (i == arr.length - 1) {
System.out.println(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
}
}在文件夹下运行 javadoc -d 目录 -author -version ArrayTool.java
生成帮助文档
3.1.7 代码块
在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，
可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。局部代码块
在方法中出现；限定变量生命周期(作用域)，及早释放，提高内存利用率
构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块 在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。和创建对象无关。
静态代码块（多个静态代码块之间是按照定义的顺序执行，自上而下）--->构造代码块（多个构造代码块之间是按照定义的顺序执行，自上而下）--->构造方法
public class CodeKuaiDemo {
//在类中方法外出现，并加上static修饰
static {
System.out.println("这是静态代码块2。。。。");
}
CodeKuaiDemo(){
System.out.println("这是我们自己提供的构造方法");
}
//构造代码块定义在类中方法外的，这个在创建对象的时候执行
{
int a = 10;
System.out.println("hello World2构造代码块");
}
//在类中方法外出现，并加上static修饰
static {
System.out.println("这是静态代码块3。。。。");
}
//构造代码块定义在类中方法外的，这个在创建对象的时候执行
{
int a = 10;
System.out.println("hello World3构造代码块");
}
//在类中方法外出现，并加上static修饰
static {
System.out.println("这是静态代码块1。。。。");
}
public static void main(String[] args) {
//局部代码块，在方法中出现
// {
// int a = 10;
// System.out.println("hello World");
// }
// System.out.println(a);
CodeKuaiDemo codeKuaiDemo = new CodeKuaiDemo();
System.out.println("=========================");
CodeKuaiDemo codeKuaiDemo2 = new CodeKuaiDemo();
}
}
扫一扫
114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
