一.数组练习回顾
1.例题1，随机访问数组中的数据。
2.例题2，统计数组中的奇数和偶数的个数。
package Practice;
//统计数组中的奇数和偶数的个数。
public class Practice_07 {
public static void main(String[] args) {
int [] a = new int[] {
24,23,38,42,4,8,2,32,18,46};
Method(a);//统计奇数和偶数的个数。
}
public static void Method(int [] x) {
int single_= 0;//定义奇数的个数。
int double_= 0;//定义偶数的个数。
for(int i=0;i<x.length;i++)
{
if(x[i]%2==0)
{
double_++;
}
else
{
single_++;
}
}
System.out.println("奇数的个数为:" + single_);
System.out.println("偶数的个数为:" + double_);
}
}
3.例题3，统计数据的总和与平均值。
package Practice;
//统计数据的总和与平均值。
public class Practice_08 {
public static void main(String[] args) {
int [] a = new int[] {
24,23,38,42,4,8,2,32,18,46};
Method3(a);
}
public static void Method3(int [] x) {
int sum = 0;
for(int i=0;i<x.length;i++)
{
sum = sum + x[i];
}
int avg = sum/10;
System.out.println("数据的总和为:" + sum);
System.out.println("数据的均值为:" + avg);
}
}
4.例题4，获取数组中的最大值和最小值。
package Practice;
//获取数组中的最大值和最小值。
public class Practice_09 {
public static void main(String[] args) {
int [] a = new int[] {
24,23,38,42,4,8,2,32,18,46};
Method4(a);
}
public static void Method4(int[] x) {
int max = x[0];
for(int i=0;i<x.length;i++)
{
if(x[i]>max)
{
max = x[i];
}
}
System.out.println("数组中的最大值为:" + max);
int min = x[0];
for(int i=0;i<x.length;i++)
{
if(x[i]<min)
{
min = x[i];
}
}
System.out.println("数组中的最小值为:" + min);
}
}
二.封装
1.定义:是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。
2.优点:提高安全性和重用性。
3.private关键字:是一个权限修饰符，用于修饰成员变量和成员方法，被私有化的成员只能在本类中访问。要想修改职能，对外提供公共的get和set方法。
4.案例:类与方法。
成员方法被封装后通常比较好解决，但是成员变量被封装后，我们需要用到get和set方法才能够进行访问。
package Practice;
//测试封装。
public class Practice_10 {
public static void main(String[] args) {
student s = new student();
s.setName("Yan Dexuan2");
System.out.println(s.getName());
s.setAge(30);
System.out.println(s.getAge());
s.eat();
}
}
class student{
private int age = 24;
public void setAge(int x) {
age = x;
}
public int getAge(){
return age;
}
private String name = "Yan Dexuan";//封装属性，比较麻烦。
//提供一个set方法，用于给外界设置值。
public void setName(String x) {
name = x;
}
//提供一个get方法，用于给外界获取值。
public String getName() {
return name;
}
private void study() {
//封装方法。
System.out.println("学习");
}
public void eat() {
study();
System.out.println("吃");
}
}
5.工具快捷方式，右键source-getter and setter。
三.构造方法
1.定义:构造方法是一种特殊的方法，他是一个与类名同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法完成的，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样可以重载。
2.含参构造，与方法的重载类似。
当类中只提供含参构造时，无参构造将不存在。
当类中无构造方法时，会自动调用这个隐藏的无参构造。
package Practice;
//测试构造方法。
public class Practice_11 {
public static void main(String[] args) {
Person p = new Person();
Person p1 = new Person(1);
Person p2 = new Person("Jack");
Person p3 = new Person(123,"Jack");
}
}
class Person{
//类中隐藏了一个无参构造方法。
public Person() {
System.out.println("无参构造方法");
}
public Person(int x) {
System.out.println("含参数的构造方法");
}
public Person(String name) {
System.out.println("含参构造" + name);
}
public Person(int x,String name) {
System.out.println("含参构造" + x + name);
}
}
四.代码块
1.构造代码块:在类的内部，方法外部，的代码块。通常用于抽取构造方法中的共性代码。每次调用构造方法前都会调用构造代码块。优先于构造方法加载。
2.局部代码块:在方法里面的代码块。通常用于控制变量的作用范围，出了括号就失效。变量的范围越小越好，成员变量会有线程安全问题
3.执行顺序：构造代码块是最优先的，局部代码块顺序执行。
package Practice;
//测试构造代码块和局部代码块。
public class Practice_12 {
public static void main(String[] args) {
//实例化对象。
Teacher t = new Teacher();
Teacher t2 = new Teacher(10);
Teacher t3 = new Teacher("Yan Dexuan");
t.study();
//System.out.println(sum);
}
}
class Teacher{
//构造代码块。
{
System.out.println("这是一个构造代码块！");
}
//无参构造方法。
public Teacher(){
System.out.println("无参构造");
}
//含参构造。
public Teacher(int x) {
System.out.println("含参构造" + x);
}
public Teacher(String name) {
System.out.println("含参构造" + name);
}
public static void study() {
//局部代码块。
int sum = 10;
System.out.println(sum);
System.out.println("学习");
}
}
五.this关键字
1.定义:this代表本类对象的一个引用对象。构造函数中，this()必须放在第一行。
2.使用场景一:当变量名相同时。
3.使用场景二:构造方法之间的调用。
package Practice;
//构造方法之间的调用。
public class Practice_14 {
public static void main(String[] args) {
Demo3 d = new Demo3();
Demo3 d1 = new Demo3(1);
}
}
class Demo3{
String name;
int age;
public Demo3() {
//this(1);//无参构造中调用含参构造。
System.out.println("无参构造");
}
public Demo3(int a) {
this();
System.out.println("含参构造" + a);
}
/*
* public Demo3(String name) {
*
* this();//含参构造中调用无参构造。
*
* System.out.println("含参构造" + name);
*
* }
*/
}
七.继承
1.定义:继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。提高复用性：只要继承父类，就能有一样的功能。
2.特点:
<1>使用extends关键字。
<2>相当于子类把父类的功能复制了一份。
<3> java只支持单继承。
<4>继承可以传递（爷爷，儿子，孙子的关系）。
<5>不能继承父类的私有成员。
<6>继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展。
3.继承简单案例。
package Practice;
//测试继承。
public class Practice_15 {
public static void main(String[] args) {
Father f = new Father();
Son s = new Son();
s.read();
s.study();
}
}
class Father{
public void read() {
System.out.println("爸爸");
}
}
class Son extends Father{
public void study() {
System.out.println("儿子");
}
}